// $ANTLR 3.4 D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g 2012-11-06 06:33:16

package newcrunch.lexers;

import newcrunch.typography.TypoResults;
import newcrunch.typography.Key;
import java.util.List;
import java.util.ArrayList;
import newcrunch.typography.TokenPosition;



import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

/** A Java 1.5 grammar for ANTLR v3 derived from the spec
 *
 *  This is a very close representation of the spec; the changes
 *  are comestic (remove left recursion) and also fixes (the spec
 *  isn't exactly perfect).  I have run this on the 1.4.2 source
 *  and some nasty looking enums from 1.5, but have not really
 *  tested for 1.5 compatibility.
 *
 *  I built this with: java -Xmx100M org.antlr.Tool java.g
 *  and got two errors that are ok (for now):
 *  java.g:691:9: Decision can match input such as
 *    "'0'..'9'{'E', 'e'}{'+', '-'}'0'..'9'{'D', 'F', 'd', 'f'}"
 *    using multiple alternatives: 3, 4
 *  As a result, alternative(s) 4 were disabled for that input
 *  java.g:734:35: Decision can match input such as "{'$', 'A'..'Z',
 *    '_', 'a'..'z', '\u00C0'..'\u00D6', '\u00D8'..'\u00F6',
 *    '\u00F8'..'\u1FFF', '\u3040'..'\u318F', '\u3300'..'\u337F',
 *    '\u3400'..'\u3D2D', '\u4E00'..'\u9FFF', '\uF900'..'\uFAFF'}"
 *    using multiple alternatives: 1, 2
 *  As a result, alternative(s) 2 were disabled for that input
 *
 *  You can turn enum on/off as a keyword :)
 *
 *  Version 1.0 -- initial release July 5, 2006 (requires 3.0b2 or higher)
 *
 *  Primary author: Terence Parr, July 2006
 *
 *  Version 1.0.1 -- corrections by Koen Vanderkimpen & Marko van Dooren,
 *      October 25, 2006;
 *      fixed normalInterfaceDeclaration: now uses typeParameters instead
 *          of typeParameter (according to JLS, 3rd edition)
 *      fixed castExpression: no longer allows expression next to type
 *          (according to semantics in JLS, in contrast with syntax in JLS)
 *
 *  Version 1.0.2 -- Terence Parr, Nov 27, 2006
 *      java spec I built this from had some bizarre for-loop control.
 *          Looked weird and so I looked elsewhere...Yep, it's messed up.
 *          simplified.
 *
 *  Version 1.0.3 -- Chris Hogue, Feb 26, 2007
 *      Factored out an annotationName rule and used it in the annotation rule.
 *          Not sure why, but typeName wasn't recognizing references to inner
 *          annotations (e.g. @InterfaceName.InnerAnnotation())
 *      Factored out the elementValue section of an annotation reference.  Created
 *          elementValuePair and elementValuePairs rules, then used them in the
 *          annotation rule.  Allows it to recognize annotation references with
 *          multiple, comma separated attributes.
 *      Updated elementValueArrayInitializer so that it allows multiple elements.
 *          (It was only allowing 0 or 1 element).
 *      Updated localVariableDeclaration to allow annotations.  Interestingly the JLS
 *          doesn't appear to indicate this is legal, but it does work as of at least
 *          JDK 1.5.0_06.
 *      Moved the Identifier portion of annotationTypeElementRest to annotationMethodRest.
 *          Because annotationConstantRest already references variableDeclarator which
 *          has the Identifier portion in it, the parser would fail on constants in
 *          annotation definitions because it expected two identifiers.
 *      Added optional trailing ';' to the alternatives in annotationTypeElementRest.
 *          Wouldn't handle an inner interface that has a trailing ';'.
 *      Swapped the expression and type rule reference order in castExpression to
 *          make it check for genericized casts first.  It was failing to recognize a
 *          statement like  "Class<Byte> TYPE = (Class<Byte>)...;" because it was seeing
 *          'Class<Byte' in the cast expression as a less than expression, then failing
 *          on the '>'.
 *      Changed createdName to use typeArguments instead of nonWildcardTypeArguments.
 *         
 *      Changed the 'this' alternative in primary to allow 'identifierSuffix' rather than
 *          just 'arguments'.  The case it couldn't handle was a call to an explicit
 *          generic method invocation (e.g. this.<E>doSomething()).  Using identifierSuffix
 *          may be overly aggressive--perhaps should create a more constrained thisSuffix rule?
 *
 *  Version 1.0.4 -- Hiroaki Nakamura, May 3, 2007
 *
 *  Fixed formalParameterDecls, localVariableDeclaration, forInit,
 *  and forVarControl to use variableModifier* not 'final'? (annotation)?
 *
 *  Version 1.0.5 -- Terence, June 21, 2007
 *  --a[i].foo didn't work. Fixed unaryExpression
 *
 *  Version 1.0.6 -- John Ridgway, March 17, 2008
 *      Made "assert" a switchable keyword like "enum".
 *      Fixed compilationUnit to disallow "annotation importDeclaration ...".
 *      Changed "Identifier ('.' Identifier)*" to "qualifiedName" in more
 *          places.
 *      Changed modifier* and/or variableModifier* to classOrInterfaceModifiers,
 *          modifiers or variableModifiers, as appropriate.
 *      Renamed "bound" to "typeBound" to better match language in the JLS.
 *      Added "memberDeclaration" which rewrites to methodDeclaration or
 *      fieldDeclaration and pulled type into memberDeclaration.  So we parse
 *          type and then move on to decide whether we're dealing with a field
 *          or a method.
 *      Modified "constructorDeclaration" to use "constructorBody" instead of
 *          "methodBody".  constructorBody starts with explicitConstructorInvocation,
 *          then goes on to blockStatement*.  Pulling explicitConstructorInvocation
 *          out of expressions allowed me to simplify "primary".
 *      Changed variableDeclarator to simplify it.
 *      Changed type to use classOrInterfaceType, thus simplifying it; of course
 *          I then had to add classOrInterfaceType, but it is used in several
 *          places.
 *      Fixed annotations, old version allowed "@X(y,z)", which is illegal.
 *      Added optional comma to end of "elementValueArrayInitializer"; as per JLS.
 *      Changed annotationTypeElementRest to use normalClassDeclaration and
 *          normalInterfaceDeclaration rather than classDeclaration and
 *          interfaceDeclaration, thus getting rid of a couple of grammar ambiguities.
 *      Split localVariableDeclaration into localVariableDeclarationStatement
 *          (includes the terminating semi-colon) and localVariableDeclaration.
 *          This allowed me to use localVariableDeclaration in "forInit" clauses,
 *           simplifying them.
 *      Changed switchBlockStatementGroup to use multiple labels.  This adds an
 *          ambiguity, but if one uses appropriately greedy parsing it yields the
 *           parse that is closest to the meaning of the switch statement.
 *      Renamed "forVarControl" to "enhancedForControl" -- JLS language.
 *      Added semantic predicates to test for shift operations rather than other
 *          things.  Thus, for instance, the string "< <" will never be treated
 *          as a left-shift operator.
 *      In "creator" we rule out "nonWildcardTypeArguments" on arrayCreation,
 *          which are illegal.
 *      Moved "nonWildcardTypeArguments into innerCreator.
 *      Removed 'super' superSuffix from explicitGenericInvocation, since that
 *          is only used in explicitConstructorInvocation at the beginning of a
 *           constructorBody.  (This is part of the simplification of expressions
 *           mentioned earlier.)
 *      Simplified primary (got rid of those things that are only used in
 *          explicitConstructorInvocation).
 *      Lexer -- removed "Exponent?" from FloatingPointLiteral choice 4, since it
 *          led to an ambiguity.
 *
 *      This grammar successfully parses every .java file in the JDK 1.5 source
 *          tree (excluding those whose file names include '-', which are not
 *          valid Java compilation units).
 *
 *  Known remaining problems:
 *      "Letter" and "JavaIDDigit" are wrong.  The actual specification of
 *      "Letter" should be "a character for which the method
 *      Character.isJavaIdentifierStart(int) returns true."  A "Java
 *      letter-or-digit is a character for which the method
 *      Character.isJavaIdentifierPart(int) returns true."
 */
@SuppressWarnings({"all", "warnings", "unchecked"})
public class JavaTypoParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ABSTRACT", "AMP", "AMPAMP", "AMPEQ", "ASSERT", "BANG", "BANGEQ", "BAR", "BARBAR", "BAREQ", "BOOLEAN", "BREAK", "BYTE", "BinDigit", "BinPrefix", "CARET", "CARETEQ", "CASE", "CATCH", "CHAR", "CHARLITERAL", "CLASS", "COLON", "COMMA", "COMMENT", "CONST", "CONTINUE", "DEFAULT", "DO", "DOT", "DOUBLE", "DOUBLELITERAL", "DUMMY", "DecDigits", "DoubleSuffix", "ELLIPSIS", "ELSE", "ENUM", "EQ", "EQEQ", "EXTENDS", "EscapeSequence", "Exponent", "FALSE", "FINAL", "FINALLY", "FLOAT", "FLOATLITERAL", "FOR", "FloatSuffix", "GOTO", "GT", "HexDigit", "HexDigits", "HexPrefix", "IDENTIFIER", "IF", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "INTLITERAL", "IdentifierPart", "IdentifierStart", "IntegerNumber", "LBRACE", "LBRACKET", "LINE_COMMENT", "LONG", "LONGLITERAL", "LPAREN", "LT", "LongSuffix", "MONKEYS_AT", "NATIVE", "NEW", "NULL", "NonIntegerNumber", "PACKAGE", "PERCENT", "PERCENTEQ", "PLUS", "PLUSEQ", "PLUSPLUS", "PRIVATE", "PROTECTED", "PUBLIC", "QUES", "RBRACE", "RBRACKET", "RETURN", "RPAREN", "SEMI", "SHORT", "SLASH", "SLASHEQ", "STAR", "STAREQ", "STATIC", "STRICTFP", "STRINGLITERAL", "SUB", "SUBEQ", "SUBSUB", "SUPER", "SWITCH", "SYNCHRONIZED", "SurrogateIdentifer", "THIS", "THROW", "THROWS", "TILDE", "TRANSIENT", "TRUE", "TRY", "VOID", "VOLATILE", "WHILE", "WS"
    };

    public static final int EOF=-1;
    public static final int ABSTRACT=4;
    public static final int AMP=5;
    public static final int AMPAMP=6;
    public static final int AMPEQ=7;
    public static final int ASSERT=8;
    public static final int BANG=9;
    public static final int BANGEQ=10;
    public static final int BAR=11;
    public static final int BARBAR=12;
    public static final int BAREQ=13;
    public static final int BOOLEAN=14;
    public static final int BREAK=15;
    public static final int BYTE=16;
    public static final int BinDigit=17;
    public static final int BinPrefix=18;
    public static final int CARET=19;
    public static final int CARETEQ=20;
    public static final int CASE=21;
    public static final int CATCH=22;
    public static final int CHAR=23;
    public static final int CHARLITERAL=24;
    public static final int CLASS=25;
    public static final int COLON=26;
    public static final int COMMA=27;
    public static final int COMMENT=28;
    public static final int CONST=29;
    public static final int CONTINUE=30;
    public static final int DEFAULT=31;
    public static final int DO=32;
    public static final int DOT=33;
    public static final int DOUBLE=34;
    public static final int DOUBLELITERAL=35;
    public static final int DUMMY=36;
    public static final int DecDigits=37;
    public static final int DoubleSuffix=38;
    public static final int ELLIPSIS=39;
    public static final int ELSE=40;
    public static final int ENUM=41;
    public static final int EQ=42;
    public static final int EQEQ=43;
    public static final int EXTENDS=44;
    public static final int EscapeSequence=45;
    public static final int Exponent=46;
    public static final int FALSE=47;
    public static final int FINAL=48;
    public static final int FINALLY=49;
    public static final int FLOAT=50;
    public static final int FLOATLITERAL=51;
    public static final int FOR=52;
    public static final int FloatSuffix=53;
    public static final int GOTO=54;
    public static final int GT=55;
    public static final int HexDigit=56;
    public static final int HexDigits=57;
    public static final int HexPrefix=58;
    public static final int IDENTIFIER=59;
    public static final int IF=60;
    public static final int IMPLEMENTS=61;
    public static final int IMPORT=62;
    public static final int INSTANCEOF=63;
    public static final int INT=64;
    public static final int INTERFACE=65;
    public static final int INTLITERAL=66;
    public static final int IdentifierPart=67;
    public static final int IdentifierStart=68;
    public static final int IntegerNumber=69;
    public static final int LBRACE=70;
    public static final int LBRACKET=71;
    public static final int LINE_COMMENT=72;
    public static final int LONG=73;
    public static final int LONGLITERAL=74;
    public static final int LPAREN=75;
    public static final int LT=76;
    public static final int LongSuffix=77;
    public static final int MONKEYS_AT=78;
    public static final int NATIVE=79;
    public static final int NEW=80;
    public static final int NULL=81;
    public static final int NonIntegerNumber=82;
    public static final int PACKAGE=83;
    public static final int PERCENT=84;
    public static final int PERCENTEQ=85;
    public static final int PLUS=86;
    public static final int PLUSEQ=87;
    public static final int PLUSPLUS=88;
    public static final int PRIVATE=89;
    public static final int PROTECTED=90;
    public static final int PUBLIC=91;
    public static final int QUES=92;
    public static final int RBRACE=93;
    public static final int RBRACKET=94;
    public static final int RETURN=95;
    public static final int RPAREN=96;
    public static final int SEMI=97;
    public static final int SHORT=98;
    public static final int SLASH=99;
    public static final int SLASHEQ=100;
    public static final int STAR=101;
    public static final int STAREQ=102;
    public static final int STATIC=103;
    public static final int STRICTFP=104;
    public static final int STRINGLITERAL=105;
    public static final int SUB=106;
    public static final int SUBEQ=107;
    public static final int SUBSUB=108;
    public static final int SUPER=109;
    public static final int SWITCH=110;
    public static final int SYNCHRONIZED=111;
    public static final int SurrogateIdentifer=112;
    public static final int THIS=113;
    public static final int THROW=114;
    public static final int THROWS=115;
    public static final int TILDE=116;
    public static final int TRANSIENT=117;
    public static final int TRUE=118;
    public static final int TRY=119;
    public static final int VOID=120;
    public static final int VOLATILE=121;
    public static final int WHILE=122;
    public static final int WS=123;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public JavaTypoParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public JavaTypoParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
        this.state.ruleMemo = new HashMap[422+1];
         

    }

    public String[] getTokenNames() { return JavaTypoParser.tokenNames; }
    public String getGrammarFileName() { return "D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g"; }


    private TypoResults results = new TypoResults();

    private String newline = "\n"; //System.getProperty("line.separator");
    private int newlineLen = newline.length();

    private String originalText = "";

    private Stack<Token> encountered = new Stack<Token>();

    private boolean isStatic = false;
    private boolean isFinal = false;

    private void addStmt(int line)
    {
    	results.addStmtLine(line);
    }

    /**
    *	Convenient constructor for me to track
    *	the original code that was parsed.
    */
    public JavaTypoParser(TokenStream input, String text)
    {
    	this(input);
    	originalText = text;
    }

    public TypoResults getResults()
    {
    	return results;
    }

    //a convenient class to hold the space and newline results
    private class SpaceNewLine
    {
    	public int spaces = 0;
    	public int newlines = 0;
    }

    /**
    * Find the number of spaces and newlines at and after the given position
    * @param pos
    * @return 
    */
    private SpaceNewLine getSpaceAfter(int pos)
    {
    	SpaceNewLine result = new SpaceNewLine();
    	int len = originalText.length();
    	result.spaces = getHorizontalSpaceAfter(pos);
    	
    	while (pos < len)
    	{
    		if (originalText.charAt(pos) == ' ')
    		{
    			//only calculate the horizontal spaces up till the newline.
    			//result.spaces++;
    			pos++;
    		}
    			
    		else if (originalText.substring(pos, pos + newlineLen).equals(newline))
    		{
    			result.newlines++;
    			pos += newlineLen;
    		}
    			
    		else
    			break;
    	}
    	
    	return result;
    }

    private int getHorizontalSpaceAfter(int pos)
    {
    	int count = 0;
    	int len = originalText.length();
    	
    	while (pos < len)
    	{
    		if (originalText.charAt(pos) == ' ')
    		{
    			count++;
    			pos++;
    		}
    			
    		else
    			break;
    	}
    	
    	return count;
    }

    private int getHorizontalSpaceBefore(int pos)
    {
    	int count = 0;
    	
    	while (pos >= 0)
    	{
    		if (originalText.charAt(pos) == ' ')
    		{
    			count++;
    			pos--;
    		}
    			
    		else
    			break;
    	}
    	
    	return count;	
    }

    /**
    * Find the number of spaces and newlines at and before the given position
    * @param pos
    * @return 
    */
    private SpaceNewLine getSpaceBefore(int pos)
    {
    	SpaceNewLine result = new SpaceNewLine();
    	result.spaces = getHorizontalSpaceBefore(pos);
    	
    	while (pos >= 0)
    	{
    		if (originalText.charAt(pos) == ' ')
    		{
    			//only calculate the horizontal space before up till the newline
    			//result.spaces++;
    			pos--;
    		}
    			
    		else if (pos >= newlineLen - 1 && originalText.substring(pos - newlineLen + 1, pos + 1).equals(newline))
    		{
    			result.newlines++;
    			pos -= newlineLen;
    		}
    			
    		else
    			break;
    	}
    	
    	return result;
    }

    private void updateSpaceAfter(Token tok)
    {
    	updateSpaceAfter(tok, null);
    }

    //replaces the string in token with replacement
    private void updateSpaceAfter(Token tok, Key replacement)
    {
    	CommonToken token = (CommonToken)tok;
    	String identifier = replacement == null ? token.getText() : replacement.toString();
    	
    	int endPos = token.getStopIndex();	
    	
    	SpaceNewLine spaceNewLine = getSpaceAfter(endPos + 1);
    	
    	results.addSpaceAfter(identifier, getStart(tok), token.getLine(), token.getCharPositionInLine(), spaceNewLine.spaces);
    	results.addNewlineAfter(identifier, getStart(tok), token.getLine(), token.getCharPositionInLine(), spaceNewLine.newlines);
    }

    private void updateSpaceBefore(Token tok)
    {
    	updateSpaceBefore(tok, null);
    }

    private void updateSpaceBefore(Token tok, Key replacement)
    {
    	CommonToken token = (CommonToken)tok;
    	String identifier = replacement == null ? token.getText() : replacement.toString();
    	
    	int startPos = token.getStartIndex();
    	
    	SpaceNewLine spaceNewLine = getSpaceBefore(startPos - 1);
    	
    	results.addSpaceBefore(identifier, getStart(tok), token.getLine(), token.getCharPositionInLine(), spaceNewLine.spaces);
    	results.addNewlineBefore(identifier, getStart(tok), token.getLine(), token.getCharPositionInLine(), spaceNewLine.newlines);	
    }

    private int getStart(Token tok)
    {
    	CommonToken token = (CommonToken)tok;
    	return token.getStartIndex() - (token.getLine() - 1) * (newlineLen - 1);
    }

    private int getStop(Token tok)
    {
    	CommonToken token = (CommonToken)tok;
    	return token.getStopIndex() - (token.getLine() - 1) * (newlineLen - 1);	
    }

    private void usa(Token tok)
    {
    	updateSpaceAfter(tok);
    }

    private void usa(Token tok, Key replacement)
    {
    	updateSpaceAfter(tok, replacement);
    }

    private void usb(Token tok)
    {
    	updateSpaceBefore(tok);
    }

    private void usb(Token tok, Key replacement)
    {
    	updateSpaceBefore(tok, replacement);
    }

    private void usc(Token tok)
    {
    	updateSpaceBefore(tok);
    	updateSpaceAfter(tok);
    }

    private void usc(Token tok, Key replacement)
    {
    	updateSpaceBefore(tok, replacement);
    	updateSpaceAfter(tok, replacement);	
    }

    private void updateBrace(Token identifier, Token openBrace, Token closeBrace)
    {
    	results.addBrace(identifier, openBrace, closeBrace, getStart(openBrace), getStop(closeBrace));
    }

    //error message
    public String getErrorMessage(RecognitionException e,
    				String[] tokenNames)
    {
    	List stack = getRuleInvocationStack(e, this.getClass().getName());
    	String msg = null;
    	if ( e instanceof NoViableAltException ) {
    		NoViableAltException nvae = (NoViableAltException)e;
    		msg = " no viable alt; token="+e.token+
    		" (decision="+nvae.decisionNumber+
    		" state "+nvae.stateNumber+")"+
    		" decision=<<"+nvae.grammarDecisionDescription+">>";
    	}
    	else {
    		msg = super.getErrorMessage(e, tokenNames);
    	}
    	return stack+" "+msg;
    }

    public String getTokenErrorDisplay(Token t) {
    	return t.toString();
    }

    private Token tokStart = null; 
    private Token tokEnd = null;

    private void addStart(TypoResults.RangeType type, Token start)
    {
    	results.addRange(start.getLine(), getStart(start), type);
    }

    private void addStop(TypoResults.RangeType type, Token stop)
    {
    	results.addRange(stop.getLine(), getStop(stop), type);
    }

    private void addConstructor(Token tok)
    {
    	CommonToken token = (CommonToken)tok;
    	
    	results.addConstructor(getStart(tok), getStop(tok), token.getLine(),
    				token.getLine());
    }




    // $ANTLR start "compilationUnit"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:590:1: compilationUnit : ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* ;
    public final void compilationUnit() throws RecognitionException {
        int compilationUnit_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:5: ( ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:9: ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )*
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:9: ( ( annotations )? packageDeclaration )?
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==MONKEYS_AT) ) {
                int LA2_1 = input.LA(2);

                if ( (synpred2_JavaTypo()) ) {
                    alt2=1;
                }
            }
            else if ( (LA2_0==PACKAGE) ) {
                alt2=1;
            }
            switch (alt2) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:10: ( annotations )? packageDeclaration
                    {
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:10: ( annotations )?
                    int alt1=2;
                    int LA1_0 = input.LA(1);

                    if ( (LA1_0==MONKEYS_AT) ) {
                        alt1=1;
                    }
                    switch (alt1) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:11: annotations
                            {
                            pushFollow(FOLLOW_annotations_in_compilationUnit116);
                            annotations();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    pushFollow(FOLLOW_packageDeclaration_in_compilationUnit120);
                    packageDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:46: ( importDeclaration )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( (LA3_0==IMPORT) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:47: importDeclaration
            	    {
            	    pushFollow(FOLLOW_importDeclaration_in_compilationUnit125);
            	    importDeclaration();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:67: ( typeDeclaration )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0==ABSTRACT||LA4_0==BOOLEAN||LA4_0==BYTE||LA4_0==CHAR||LA4_0==CLASS||LA4_0==DOUBLE||LA4_0==ENUM||LA4_0==FINAL||LA4_0==FLOAT||LA4_0==IDENTIFIER||(LA4_0 >= INT && LA4_0 <= INTERFACE)||LA4_0==LONG||LA4_0==LT||(LA4_0 >= MONKEYS_AT && LA4_0 <= NATIVE)||(LA4_0 >= PRIVATE && LA4_0 <= PUBLIC)||(LA4_0 >= SEMI && LA4_0 <= SHORT)||(LA4_0 >= STATIC && LA4_0 <= STRICTFP)||LA4_0==SYNCHRONIZED||LA4_0==TRANSIENT||(LA4_0 >= VOID && LA4_0 <= VOLATILE)) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:68: typeDeclaration
            	    {
            	    pushFollow(FOLLOW_typeDeclaration_in_compilationUnit130);
            	    typeDeclaration();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);


            }

            if ( state.backtracking==0 ) {
            	 if (tokStart != null && tokEnd != null) 
            	 {
            	 	addStart(TypoResults.RangeType.HEADER_START, tokStart);
            	 	addStop(TypoResults.RangeType.HEADER_END, tokEnd);
            	 }
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 1, compilationUnit_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "compilationUnit"


    public static class packageDeclaration_return extends ParserRuleReturnScope {
    };


    // $ANTLR start "packageDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:602:1: packageDeclaration : PACKAGE qualifiedName SEMI ;
    public final JavaTypoParser.packageDeclaration_return packageDeclaration() throws RecognitionException {
        JavaTypoParser.packageDeclaration_return retval = new JavaTypoParser.packageDeclaration_return();
        retval.start = input.LT(1);

        int packageDeclaration_StartIndex = input.index();

        Token PACKAGE1=null;
        Token SEMI2=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return retval; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:608:5: ( PACKAGE qualifiedName SEMI )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:608:9: PACKAGE qualifiedName SEMI
            {
            PACKAGE1=(Token)match(input,PACKAGE,FOLLOW_PACKAGE_in_packageDeclaration158); if (state.failed) return retval;

            pushFollow(FOLLOW_qualifiedName_in_packageDeclaration160);
            qualifiedName();

            state._fsp--;
            if (state.failed) return retval;

            SEMI2=(Token)match(input,SEMI,FOLLOW_SEMI_in_packageDeclaration162); if (state.failed) return retval;

            if ( state.backtracking==0 ) { usa(PACKAGE1); usb(SEMI2); addStmt((SEMI2!=null?SEMI2.getLine():0)); }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {
            	tokStart = ((Token)retval.start);
            	tokEnd = ((Token)retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 2, packageDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "packageDeclaration"


    public static class importDeclaration_return extends ParserRuleReturnScope {
    };


    // $ANTLR start "importDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:611:1: importDeclaration : ( IMPORT ( STATIC )? IDENTIFIER DOT '*' SEMI | IMPORT ( STATIC )? IDENTIFIER (d= DOT IDENTIFIER )+ (e= DOT '*' )? SEMI );
    public final JavaTypoParser.importDeclaration_return importDeclaration() throws RecognitionException {
        JavaTypoParser.importDeclaration_return retval = new JavaTypoParser.importDeclaration_return();
        retval.start = input.LT(1);

        int importDeclaration_StartIndex = input.index();

        Token d=null;
        Token e=null;
        Token STATIC3=null;
        Token IMPORT4=null;
        Token DOT5=null;
        Token SEMI6=null;
        Token STATIC7=null;
        Token IMPORT8=null;
        Token SEMI9=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return retval; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:617:5: ( IMPORT ( STATIC )? IDENTIFIER DOT '*' SEMI | IMPORT ( STATIC )? IDENTIFIER (d= DOT IDENTIFIER )+ (e= DOT '*' )? SEMI )
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( (LA9_0==IMPORT) ) {
                int LA9_1 = input.LA(2);

                if ( (LA9_1==STATIC) ) {
                    int LA9_2 = input.LA(3);

                    if ( (LA9_2==IDENTIFIER) ) {
                        int LA9_3 = input.LA(4);

                        if ( (LA9_3==DOT) ) {
                            int LA9_4 = input.LA(5);

                            if ( (LA9_4==STAR) ) {
                                alt9=1;
                            }
                            else if ( (LA9_4==IDENTIFIER) ) {
                                alt9=2;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return retval;}
                                NoViableAltException nvae =
                                    new NoViableAltException("", 9, 4, input);

                                throw nvae;

                            }
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return retval;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 9, 3, input);

                            throw nvae;

                        }
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 9, 2, input);

                        throw nvae;

                    }
                }
                else if ( (LA9_1==IDENTIFIER) ) {
                    int LA9_3 = input.LA(3);

                    if ( (LA9_3==DOT) ) {
                        int LA9_4 = input.LA(4);

                        if ( (LA9_4==STAR) ) {
                            alt9=1;
                        }
                        else if ( (LA9_4==IDENTIFIER) ) {
                            alt9=2;
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return retval;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 9, 4, input);

                            throw nvae;

                        }
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 9, 3, input);

                        throw nvae;

                    }
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 9, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;

            }
            switch (alt9) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:617:9: IMPORT ( STATIC )? IDENTIFIER DOT '*' SEMI
                    {
                    IMPORT4=(Token)match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration191); if (state.failed) return retval;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:618:9: ( STATIC )?
                    int alt5=2;
                    int LA5_0 = input.LA(1);

                    if ( (LA5_0==STATIC) ) {
                        alt5=1;
                    }
                    switch (alt5) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:618:10: STATIC
                            {
                            STATIC3=(Token)match(input,STATIC,FOLLOW_STATIC_in_importDeclaration203); if (state.failed) return retval;

                            if ( state.backtracking==0 ) { usa(STATIC3); }

                            }
                            break;

                    }


                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration226); if (state.failed) return retval;

                    DOT5=(Token)match(input,DOT,FOLLOW_DOT_in_importDeclaration228); if (state.failed) return retval;

                    match(input,STAR,FOLLOW_STAR_in_importDeclaration230); if (state.failed) return retval;

                    SEMI6=(Token)match(input,SEMI,FOLLOW_SEMI_in_importDeclaration240); if (state.failed) return retval;

                    if ( state.backtracking==0 ) { usa(IMPORT4); usc(DOT5); usb(SEMI6); addStmt((SEMI6!=null?SEMI6.getLine():0)); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:623:9: IMPORT ( STATIC )? IDENTIFIER (d= DOT IDENTIFIER )+ (e= DOT '*' )? SEMI
                    {
                    IMPORT8=(Token)match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration267); if (state.failed) return retval;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:624:9: ( STATIC )?
                    int alt6=2;
                    int LA6_0 = input.LA(1);

                    if ( (LA6_0==STATIC) ) {
                        alt6=1;
                    }
                    switch (alt6) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:624:10: STATIC
                            {
                            STATIC7=(Token)match(input,STATIC,FOLLOW_STATIC_in_importDeclaration278); if (state.failed) return retval;

                            if ( state.backtracking==0 ) { usa(STATIC7); }

                            }
                            break;

                    }


                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration301); if (state.failed) return retval;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:627:9: (d= DOT IDENTIFIER )+
                    int cnt7=0;
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( (LA7_0==DOT) ) {
                            int LA7_1 = input.LA(2);

                            if ( (LA7_1==IDENTIFIER) ) {
                                alt7=1;
                            }


                        }


                        switch (alt7) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:627:10: d= DOT IDENTIFIER
                    	    {
                    	    d=(Token)match(input,DOT,FOLLOW_DOT_in_importDeclaration314); if (state.failed) return retval;

                    	    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration316); if (state.failed) return retval;

                    	    if ( state.backtracking==0 ) { usc(d); }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt7 >= 1 ) break loop7;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(7, input);
                                throw eee;
                        }
                        cnt7++;
                    } while (true);


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:629:9: (e= DOT '*' )?
                    int alt8=2;
                    int LA8_0 = input.LA(1);

                    if ( (LA8_0==DOT) ) {
                        alt8=1;
                    }
                    switch (alt8) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:629:10: e= DOT '*'
                            {
                            e=(Token)match(input,DOT,FOLLOW_DOT_in_importDeclaration342); if (state.failed) return retval;

                            match(input,STAR,FOLLOW_STAR_in_importDeclaration344); if (state.failed) return retval;

                            if ( state.backtracking==0 ) { usc(e); }

                            }
                            break;

                    }


                    SEMI9=(Token)match(input,SEMI,FOLLOW_SEMI_in_importDeclaration367); if (state.failed) return retval;

                    if ( state.backtracking==0 ) { usa(IMPORT8); usb(SEMI9); addStmt((SEMI9!=null?SEMI9.getLine():0)); }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {
            	tokStart = ((Token)retval.start);
            	tokEnd = ((Token)retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 3, importDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "importDeclaration"



    // $ANTLR start "qualifiedImportName"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:635:1: qualifiedImportName : IDENTIFIER ( DOT IDENTIFIER )* ;
    public final void qualifiedImportName() throws RecognitionException {
        int qualifiedImportName_StartIndex = input.index();

        Token DOT10=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:636:5: ( IDENTIFIER ( DOT IDENTIFIER )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:636:9: IDENTIFIER ( DOT IDENTIFIER )*
            {
            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName397); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:637:9: ( DOT IDENTIFIER )*
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( (LA10_0==DOT) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:637:10: DOT IDENTIFIER
            	    {
            	    DOT10=(Token)match(input,DOT,FOLLOW_DOT_in_qualifiedImportName408); if (state.failed) return ;

            	    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName410); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(DOT10); }

            	    }
            	    break;

            	default :
            	    break loop10;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 4, qualifiedImportName_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "qualifiedImportName"


    public static class typeDeclaration_return extends ParserRuleReturnScope {
    };


    // $ANTLR start "typeDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:641:1: typeDeclaration : ( classOrInterfaceDeclaration | SEMI );
    public final JavaTypoParser.typeDeclaration_return typeDeclaration() throws RecognitionException {
        JavaTypoParser.typeDeclaration_return retval = new JavaTypoParser.typeDeclaration_return();
        retval.start = input.LT(1);

        int typeDeclaration_StartIndex = input.index();

        Token SEMI11=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return retval; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:647:5: ( classOrInterfaceDeclaration | SEMI )
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0==ABSTRACT||LA11_0==BOOLEAN||LA11_0==BYTE||LA11_0==CHAR||LA11_0==CLASS||LA11_0==DOUBLE||LA11_0==ENUM||LA11_0==FINAL||LA11_0==FLOAT||LA11_0==IDENTIFIER||(LA11_0 >= INT && LA11_0 <= INTERFACE)||LA11_0==LONG||LA11_0==LT||(LA11_0 >= MONKEYS_AT && LA11_0 <= NATIVE)||(LA11_0 >= PRIVATE && LA11_0 <= PUBLIC)||LA11_0==SHORT||(LA11_0 >= STATIC && LA11_0 <= STRICTFP)||LA11_0==SYNCHRONIZED||LA11_0==TRANSIENT||(LA11_0 >= VOID && LA11_0 <= VOLATILE)) ) {
                alt11=1;
            }
            else if ( (LA11_0==SEMI) ) {
                alt11=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;

            }
            switch (alt11) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:647:9: classOrInterfaceDeclaration
                    {
                    pushFollow(FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration448);
                    classOrInterfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:648:9: SEMI
                    {
                    SEMI11=(Token)match(input,SEMI,FOLLOW_SEMI_in_typeDeclaration458); if (state.failed) return retval;

                    if ( state.backtracking==0 ) { usb(SEMI11); }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {
            	addStart(TypoResults.RangeType.TYPE_DECL_START, ((Token)retval.start));
            	addStop(TypoResults.RangeType.TYPE_DECL_END, ((Token)retval.stop));
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 5, typeDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "typeDeclaration"


    protected static class classOrInterfaceDeclaration_scope {
        Token first;
    }
    protected Stack classOrInterfaceDeclaration_stack = new Stack();



    // $ANTLR start "classOrInterfaceDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:651:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration );
    public final void classOrInterfaceDeclaration() throws RecognitionException {
        classOrInterfaceDeclaration_stack.push(new classOrInterfaceDeclaration_scope());
        int classOrInterfaceDeclaration_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:655:5: ( classDeclaration | interfaceDeclaration )
            int alt12=2;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA12_1 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA12_2 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA12_3 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA12_4 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA12_5 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA12_6 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA12_7 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA12_8 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA12_9 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA12_10 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA12_11 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA12_12 = input.LA(2);

                if ( (synpred12_JavaTypo()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 12, input);

                    throw nvae;

                }
                }
                break;
            case CLASS:
            case ENUM:
                {
                alt12=1;
                }
                break;
            case INTERFACE:
                {
                alt12=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;

            }

            switch (alt12) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:655:10: classDeclaration
                    {
                    pushFollow(FOLLOW_classDeclaration_in_classOrInterfaceDeclaration484);
                    classDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:656:9: interfaceDeclaration
                    {
                    pushFollow(FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration494);
                    interfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 6, classOrInterfaceDeclaration_StartIndex); }

            classOrInterfaceDeclaration_stack.pop();
        }
        return ;
    }
    // $ANTLR end "classOrInterfaceDeclaration"



    // $ANTLR start "modifiers"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:660:1: modifiers : ( annotation | PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP )* ;
    public final void modifiers() throws RecognitionException {
        int modifiers_StartIndex = input.index();

        Token PUBLIC12=null;
        Token PROTECTED13=null;
        Token PRIVATE14=null;
        Token STATIC15=null;
        Token ABSTRACT16=null;
        Token FINAL17=null;
        Token NATIVE18=null;
        Token SYNCHRONIZED19=null;
        Token TRANSIENT20=null;
        Token VOLATILE21=null;
        Token STRICTFP22=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:661:5: ( ( annotation | PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:662:5: ( annotation | PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP )*
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:662:5: ( annotation | PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP )*
            loop13:
            do {
                int alt13=13;
                switch ( input.LA(1) ) {
                case MONKEYS_AT:
                    {
                    int LA13_2 = input.LA(2);

                    if ( (LA13_2==IDENTIFIER) ) {
                        alt13=1;
                    }


                    }
                    break;
                case PUBLIC:
                    {
                    alt13=2;
                    }
                    break;
                case PROTECTED:
                    {
                    alt13=3;
                    }
                    break;
                case PRIVATE:
                    {
                    alt13=4;
                    }
                    break;
                case STATIC:
                    {
                    alt13=5;
                    }
                    break;
                case ABSTRACT:
                    {
                    alt13=6;
                    }
                    break;
                case FINAL:
                    {
                    alt13=7;
                    }
                    break;
                case NATIVE:
                    {
                    alt13=8;
                    }
                    break;
                case SYNCHRONIZED:
                    {
                    alt13=9;
                    }
                    break;
                case TRANSIENT:
                    {
                    alt13=10;
                    }
                    break;
                case VOLATILE:
                    {
                    alt13=11;
                    }
                    break;
                case STRICTFP:
                    {
                    alt13=12;
                    }
                    break;

                }

                switch (alt13) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:662:10: annotation
            	    {
            	    pushFollow(FOLLOW_annotation_in_modifiers529);
            	    annotation();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;
            	case 2 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:663:9: PUBLIC
            	    {
            	    PUBLIC12=(Token)match(input,PUBLIC,FOLLOW_PUBLIC_in_modifiers539); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(PUBLIC12); }

            	    }
            	    break;
            	case 3 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:664:9: PROTECTED
            	    {
            	    PROTECTED13=(Token)match(input,PROTECTED,FOLLOW_PROTECTED_in_modifiers552); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(PROTECTED13); }

            	    }
            	    break;
            	case 4 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:665:9: PRIVATE
            	    {
            	    PRIVATE14=(Token)match(input,PRIVATE,FOLLOW_PRIVATE_in_modifiers564); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(PRIVATE14); }

            	    }
            	    break;
            	case 5 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:666:9: STATIC
            	    {
            	    STATIC15=(Token)match(input,STATIC,FOLLOW_STATIC_in_modifiers577); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(STATIC15); isStatic = true; }

            	    }
            	    break;
            	case 6 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:667:9: ABSTRACT
            	    {
            	    ABSTRACT16=(Token)match(input,ABSTRACT,FOLLOW_ABSTRACT_in_modifiers590); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(ABSTRACT16); }

            	    }
            	    break;
            	case 7 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:668:9: FINAL
            	    {
            	    FINAL17=(Token)match(input,FINAL,FOLLOW_FINAL_in_modifiers602); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(FINAL17); isFinal = true; }

            	    }
            	    break;
            	case 8 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:669:9: NATIVE
            	    {
            	    NATIVE18=(Token)match(input,NATIVE,FOLLOW_NATIVE_in_modifiers615); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(NATIVE18); }

            	    }
            	    break;
            	case 9 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:670:9: SYNCHRONIZED
            	    {
            	    SYNCHRONIZED19=(Token)match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_modifiers628); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(SYNCHRONIZED19); }

            	    }
            	    break;
            	case 10 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:671:9: TRANSIENT
            	    {
            	    TRANSIENT20=(Token)match(input,TRANSIENT,FOLLOW_TRANSIENT_in_modifiers640); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(TRANSIENT20); }

            	    }
            	    break;
            	case 11 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:672:9: VOLATILE
            	    {
            	    VOLATILE21=(Token)match(input,VOLATILE,FOLLOW_VOLATILE_in_modifiers652); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(VOLATILE21); }

            	    }
            	    break;
            	case 12 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:673:9: STRICTFP
            	    {
            	    STRICTFP22=(Token)match(input,STRICTFP,FOLLOW_STRICTFP_in_modifiers664); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(STRICTFP22); }

            	    }
            	    break;

            	default :
            	    break loop13;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 7, modifiers_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "modifiers"


    public static class mods_return extends ParserRuleReturnScope {
    };


    // $ANTLR start "mods"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:677:1: mods : ( PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP )* ;
    public final JavaTypoParser.mods_return mods() throws RecognitionException {
        JavaTypoParser.mods_return retval = new JavaTypoParser.mods_return();
        retval.start = input.LT(1);

        int mods_StartIndex = input.index();

        Token PUBLIC23=null;
        Token PROTECTED24=null;
        Token PRIVATE25=null;
        Token STATIC26=null;
        Token ABSTRACT27=null;
        Token FINAL28=null;
        Token NATIVE29=null;
        Token SYNCHRONIZED30=null;
        Token TRANSIENT31=null;
        Token VOLATILE32=null;
        Token STRICTFP33=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return retval; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:678:2: ( ( PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:679:5: ( PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP )*
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:679:5: ( PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP )*
            loop14:
            do {
                int alt14=12;
                switch ( input.LA(1) ) {
                case PUBLIC:
                    {
                    alt14=1;
                    }
                    break;
                case PROTECTED:
                    {
                    alt14=2;
                    }
                    break;
                case PRIVATE:
                    {
                    alt14=3;
                    }
                    break;
                case STATIC:
                    {
                    alt14=4;
                    }
                    break;
                case ABSTRACT:
                    {
                    alt14=5;
                    }
                    break;
                case FINAL:
                    {
                    alt14=6;
                    }
                    break;
                case NATIVE:
                    {
                    alt14=7;
                    }
                    break;
                case SYNCHRONIZED:
                    {
                    alt14=8;
                    }
                    break;
                case TRANSIENT:
                    {
                    alt14=9;
                    }
                    break;
                case VOLATILE:
                    {
                    alt14=10;
                    }
                    break;
                case STRICTFP:
                    {
                    alt14=11;
                    }
                    break;

                }

                switch (alt14) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:679:9: PUBLIC
            	    {
            	    PUBLIC23=(Token)match(input,PUBLIC,FOLLOW_PUBLIC_in_mods699); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(PUBLIC23); }

            	    }
            	    break;
            	case 2 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:680:9: PROTECTED
            	    {
            	    PROTECTED24=(Token)match(input,PROTECTED,FOLLOW_PROTECTED_in_mods712); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(PROTECTED24); }

            	    }
            	    break;
            	case 3 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:681:9: PRIVATE
            	    {
            	    PRIVATE25=(Token)match(input,PRIVATE,FOLLOW_PRIVATE_in_mods724); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(PRIVATE25); }

            	    }
            	    break;
            	case 4 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:682:9: STATIC
            	    {
            	    STATIC26=(Token)match(input,STATIC,FOLLOW_STATIC_in_mods737); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(STATIC26); }

            	    }
            	    break;
            	case 5 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:683:9: ABSTRACT
            	    {
            	    ABSTRACT27=(Token)match(input,ABSTRACT,FOLLOW_ABSTRACT_in_mods750); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(ABSTRACT27); }

            	    }
            	    break;
            	case 6 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:684:9: FINAL
            	    {
            	    FINAL28=(Token)match(input,FINAL,FOLLOW_FINAL_in_mods762); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(FINAL28); }

            	    }
            	    break;
            	case 7 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:685:9: NATIVE
            	    {
            	    NATIVE29=(Token)match(input,NATIVE,FOLLOW_NATIVE_in_mods775); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(NATIVE29); }

            	    }
            	    break;
            	case 8 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:686:9: SYNCHRONIZED
            	    {
            	    SYNCHRONIZED30=(Token)match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_mods788); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(SYNCHRONIZED30); }

            	    }
            	    break;
            	case 9 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:687:9: TRANSIENT
            	    {
            	    TRANSIENT31=(Token)match(input,TRANSIENT,FOLLOW_TRANSIENT_in_mods800); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(TRANSIENT31); }

            	    }
            	    break;
            	case 10 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:688:9: VOLATILE
            	    {
            	    VOLATILE32=(Token)match(input,VOLATILE,FOLLOW_VOLATILE_in_mods812); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(VOLATILE32); }

            	    }
            	    break;
            	case 11 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:689:9: STRICTFP
            	    {
            	    STRICTFP33=(Token)match(input,STRICTFP,FOLLOW_STRICTFP_in_mods824); if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usa(STRICTFP33); }

            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 8, mods_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "mods"



    // $ANTLR start "variableModifiers"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:694:1: variableModifiers : ( FINAL | annotation )* ;
    public final void variableModifiers() throws RecognitionException {
        int variableModifiers_StartIndex = input.index();

        Token FINAL34=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:695:5: ( ( FINAL | annotation )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:695:9: ( FINAL | annotation )*
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:695:9: ( FINAL | annotation )*
            loop15:
            do {
                int alt15=3;
                int LA15_0 = input.LA(1);

                if ( (LA15_0==FINAL) ) {
                    alt15=1;
                }
                else if ( (LA15_0==MONKEYS_AT) ) {
                    alt15=2;
                }


                switch (alt15) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:695:13: FINAL
            	    {
            	    FINAL34=(Token)match(input,FINAL,FOLLOW_FINAL_in_variableModifiers855); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(FINAL34); }

            	    }
            	    break;
            	case 2 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:696:13: annotation
            	    {
            	    pushFollow(FOLLOW_annotation_in_variableModifiers871);
            	    annotation();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop15;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 9, variableModifiers_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "variableModifiers"


    protected static class classDeclaration_scope {
        Token first;
    }
    protected Stack classDeclaration_stack = new Stack();


    public static class classDeclaration_return extends ParserRuleReturnScope {
    };


    // $ANTLR start "classDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:701:1: classDeclaration : ( normalClassDeclaration | enumDeclaration );
    public final JavaTypoParser.classDeclaration_return classDeclaration() throws RecognitionException {
        classDeclaration_stack.push(new classDeclaration_scope());
        JavaTypoParser.classDeclaration_return retval = new JavaTypoParser.classDeclaration_return();
        retval.start = input.LT(1);

        int classDeclaration_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return retval; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:705:5: ( normalClassDeclaration | enumDeclaration )
            int alt16=2;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA16_1 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA16_2 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA16_3 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA16_4 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA16_5 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA16_6 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA16_7 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA16_8 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA16_9 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA16_10 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA16_11 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA16_12 = input.LA(2);

                if ( (synpred38_JavaTypo()) ) {
                    alt16=1;
                }
                else if ( (true) ) {
                    alt16=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 12, input);

                    throw nvae;

                }
                }
                break;
            case CLASS:
                {
                alt16=1;
                }
                break;
            case ENUM:
                {
                alt16=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                throw nvae;

            }

            switch (alt16) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:705:9: normalClassDeclaration
                    {
                    pushFollow(FOLLOW_normalClassDeclaration_in_classDeclaration910);
                    normalClassDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:706:9: enumDeclaration
                    {
                    pushFollow(FOLLOW_enumDeclaration_in_classDeclaration921);
                    enumDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;

                    }
                    break;

            }
            retval.stop = input.LT(-1);


        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 10, classDeclaration_StartIndex); }

            classDeclaration_stack.pop();
        }
        return retval;
    }
    // $ANTLR end "classDeclaration"



    // $ANTLR start "normalClassDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:709:1: normalClassDeclaration : ( annotations )? mods CLASS IDENTIFIER ( typeParameters )? ( EXTENDS type )? ( IMPLEMENTS typeList )? classBody ;
    public final void normalClassDeclaration() throws RecognitionException {
        int normalClassDeclaration_StartIndex = input.index();

        Token EXTENDS35=null;
        Token IMPLEMENTS36=null;
        Token IDENTIFIER39=null;
        Token CLASS40=null;
        JavaTypoParser.mods_return mods37 =null;

        JavaTypoParser.classBody_return classBody38 =null;


        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:710:5: ( ( annotations )? mods CLASS IDENTIFIER ( typeParameters )? ( EXTENDS type )? ( IMPLEMENTS typeList )? classBody )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:710:9: ( annotations )? mods CLASS IDENTIFIER ( typeParameters )? ( EXTENDS type )? ( IMPLEMENTS typeList )? classBody
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:710:9: ( annotations )?
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( (LA17_0==MONKEYS_AT) ) {
                alt17=1;
            }
            switch (alt17) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:710:9: annotations
                    {
                    pushFollow(FOLLOW_annotations_in_normalClassDeclaration942);
                    annotations();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            pushFollow(FOLLOW_mods_in_normalClassDeclaration945);
            mods37=mods();

            state._fsp--;
            if (state.failed) return ;

            CLASS40=(Token)match(input,CLASS,FOLLOW_CLASS_in_normalClassDeclaration947); if (state.failed) return ;

            IDENTIFIER39=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalClassDeclaration949); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:711:9: ( typeParameters )?
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0==LT) ) {
                alt18=1;
            }
            switch (alt18) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:711:10: typeParameters
                    {
                    pushFollow(FOLLOW_typeParameters_in_normalClassDeclaration960);
                    typeParameters();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:713:9: ( EXTENDS type )?
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( (LA19_0==EXTENDS) ) {
                alt19=1;
            }
            switch (alt19) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:713:10: EXTENDS type
                    {
                    EXTENDS35=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_normalClassDeclaration982); if (state.failed) return ;

                    pushFollow(FOLLOW_type_in_normalClassDeclaration984);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(EXTENDS35); }

                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:715:9: ( IMPLEMENTS typeList )?
            int alt20=2;
            int LA20_0 = input.LA(1);

            if ( (LA20_0==IMPLEMENTS) ) {
                alt20=1;
            }
            switch (alt20) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:715:10: IMPLEMENTS typeList
                    {
                    IMPLEMENTS36=(Token)match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_normalClassDeclaration1008); if (state.failed) return ;

                    pushFollow(FOLLOW_typeList_in_normalClassDeclaration1010);
                    typeList();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(IMPLEMENTS36); }

                    }
                    break;

            }


            pushFollow(FOLLOW_classBody_in_normalClassDeclaration1033);
            classBody38=classBody();

            state._fsp--;
            if (state.failed) return ;

            if ( state.backtracking==0 ) { updateBrace((mods37!=null?((Token)mods37.start):null), (classBody38!=null?((Token)classBody38.start):null), (classBody38!=null?((Token)classBody38.stop):null)); }

            if ( state.backtracking==0 ) {  results.addClassLength((IDENTIFIER39!=null?IDENTIFIER39.getText():null), (classBody38!=null?((Token)classBody38.start):null).getLine(), (classBody38!=null?((Token)classBody38.stop):null).getLine()); 
                       usa(CLASS40); results.addClassInterfaceName((IDENTIFIER39!=null?IDENTIFIER39.getText():null), getStart(IDENTIFIER39), (IDENTIFIER39!=null?IDENTIFIER39.getLine():0), (IDENTIFIER39!=null?IDENTIFIER39.getCharPositionInLine():0)); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 11, normalClassDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "normalClassDeclaration"



    // $ANTLR start "typeParameters"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:724:1: typeParameters : LT typeParameter ( COMMA typeParameter )* GT ;
    public final void typeParameters() throws RecognitionException {
        int typeParameters_StartIndex = input.index();

        Token COMMA41=null;
        Token LT42=null;
        Token GT43=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:725:5: ( LT typeParameter ( COMMA typeParameter )* GT )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:725:9: LT typeParameter ( COMMA typeParameter )* GT
            {
            LT42=(Token)match(input,LT,FOLLOW_LT_in_typeParameters1082); if (state.failed) return ;

            pushFollow(FOLLOW_typeParameter_in_typeParameters1096);
            typeParameter();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:727:13: ( COMMA typeParameter )*
            loop21:
            do {
                int alt21=2;
                int LA21_0 = input.LA(1);

                if ( (LA21_0==COMMA) ) {
                    alt21=1;
                }


                switch (alt21) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:727:14: COMMA typeParameter
            	    {
            	    COMMA41=(Token)match(input,COMMA,FOLLOW_COMMA_in_typeParameters1111); if (state.failed) return ;

            	    pushFollow(FOLLOW_typeParameter_in_typeParameters1113);
            	    typeParameter();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(COMMA41); }

            	    }
            	    break;

            	default :
            	    break loop21;
                }
            } while (true);


            GT43=(Token)match(input,GT,FOLLOW_GT_in_typeParameters1140); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(LT42, Key.LTYPE); usb(GT43, Key.RTYPE); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 12, typeParameters_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "typeParameters"



    // $ANTLR start "typeParameter"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:733:1: typeParameter : IDENTIFIER ( EXTENDS typeBound )? ;
    public final void typeParameter() throws RecognitionException {
        int typeParameter_StartIndex = input.index();

        Token EXTENDS44=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:734:5: ( IDENTIFIER ( EXTENDS typeBound )? )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:734:9: IDENTIFIER ( EXTENDS typeBound )?
            {
            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeParameter1170); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:735:9: ( EXTENDS typeBound )?
            int alt22=2;
            int LA22_0 = input.LA(1);

            if ( (LA22_0==EXTENDS) ) {
                alt22=1;
            }
            switch (alt22) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:735:10: EXTENDS typeBound
                    {
                    EXTENDS44=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_typeParameter1181); if (state.failed) return ;

                    pushFollow(FOLLOW_typeBound_in_typeParameter1183);
                    typeBound();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(EXTENDS44); }

                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 13, typeParameter_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "typeParameter"



    // $ANTLR start "typeBound"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:740:1: typeBound : type ( AMP type )* ;
    public final void typeBound() throws RecognitionException {
        int typeBound_StartIndex = input.index();

        Token AMP45=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:741:5: ( type ( AMP type )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:741:9: type ( AMP type )*
            {
            pushFollow(FOLLOW_type_in_typeBound1217);
            type();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:742:9: ( AMP type )*
            loop23:
            do {
                int alt23=2;
                int LA23_0 = input.LA(1);

                if ( (LA23_0==AMP) ) {
                    alt23=1;
                }


                switch (alt23) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:742:10: AMP type
            	    {
            	    AMP45=(Token)match(input,AMP,FOLLOW_AMP_in_typeBound1228); if (state.failed) return ;

            	    pushFollow(FOLLOW_type_in_typeBound1230);
            	    type();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(AMP45, Key.AND_TYPE); }

            	    }
            	    break;

            	default :
            	    break loop23;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 14, typeBound_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "typeBound"



    // $ANTLR start "enumDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:747:1: enumDeclaration : ( annotations )? mods ( ENUM ) IDENTIFIER ( IMPLEMENTS typeList )? enumBody ;
    public final void enumDeclaration() throws RecognitionException {
        int enumDeclaration_StartIndex = input.index();

        Token ENUM46=null;
        Token IMPLEMENTS47=null;
        JavaTypoParser.mods_return mods48 =null;


        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:748:5: ( ( annotations )? mods ( ENUM ) IDENTIFIER ( IMPLEMENTS typeList )? enumBody )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:748:9: ( annotations )? mods ( ENUM ) IDENTIFIER ( IMPLEMENTS typeList )? enumBody
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:748:9: ( annotations )?
            int alt24=2;
            int LA24_0 = input.LA(1);

            if ( (LA24_0==MONKEYS_AT) ) {
                alt24=1;
            }
            switch (alt24) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:748:9: annotations
                    {
                    pushFollow(FOLLOW_annotations_in_enumDeclaration1264);
                    annotations();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            pushFollow(FOLLOW_mods_in_enumDeclaration1267);
            mods48=mods();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:749:9: ( ENUM )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:749:10: ENUM
            {
            ENUM46=(Token)match(input,ENUM,FOLLOW_ENUM_in_enumDeclaration1279); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(ENUM46); }

            }


            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumDeclaration1302); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:752:9: ( IMPLEMENTS typeList )?
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==IMPLEMENTS) ) {
                alt25=1;
            }
            switch (alt25) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:752:10: IMPLEMENTS typeList
                    {
                    IMPLEMENTS47=(Token)match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_enumDeclaration1313); if (state.failed) return ;

                    pushFollow(FOLLOW_typeList_in_enumDeclaration1315);
                    typeList();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(IMPLEMENTS47); }

                    }
                    break;

            }


            if ( state.backtracking==0 ) { ((classDeclaration_scope)classDeclaration_stack.peek()).first = (mods48!=null?((Token)mods48.start):null); }

            pushFollow(FOLLOW_enumBody_in_enumDeclaration1348);
            enumBody();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 15, enumDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "enumDeclaration"



    // $ANTLR start "enumBody"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:759:1: enumBody : LBRACE ( enumConstants )? ( COMMA )? ( enumBodyDeclarations )? RBRACE ;
    public final void enumBody() throws RecognitionException {
        int enumBody_StartIndex = input.index();

        Token COMMA49=null;
        Token LBRACE50=null;
        Token RBRACE51=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:760:5: ( LBRACE ( enumConstants )? ( COMMA )? ( enumBodyDeclarations )? RBRACE )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:760:9: LBRACE ( enumConstants )? ( COMMA )? ( enumBodyDeclarations )? RBRACE
            {
            LBRACE50=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_enumBody1373); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:761:9: ( enumConstants )?
            int alt26=2;
            int LA26_0 = input.LA(1);

            if ( (LA26_0==IDENTIFIER||LA26_0==MONKEYS_AT) ) {
                alt26=1;
            }
            switch (alt26) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:761:10: enumConstants
                    {
                    pushFollow(FOLLOW_enumConstants_in_enumBody1384);
                    enumConstants();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:763:9: ( COMMA )?
            int alt27=2;
            int LA27_0 = input.LA(1);

            if ( (LA27_0==COMMA) ) {
                alt27=1;
            }
            switch (alt27) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:763:10: COMMA
                    {
                    COMMA49=(Token)match(input,COMMA,FOLLOW_COMMA_in_enumBody1407); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(COMMA49); }

                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:764:9: ( enumBodyDeclarations )?
            int alt28=2;
            int LA28_0 = input.LA(1);

            if ( (LA28_0==SEMI) ) {
                alt28=1;
            }
            switch (alt28) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:764:10: enumBodyDeclarations
                    {
                    pushFollow(FOLLOW_enumBodyDeclarations_in_enumBody1424);
                    enumBodyDeclarations();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            RBRACE51=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_enumBody1446); if (state.failed) return ;

            if ( state.backtracking==0 ) { updateBrace(((classDeclaration_scope)classDeclaration_stack.peek()).first, LBRACE50, RBRACE51); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 16, enumBody_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "enumBody"



    // $ANTLR start "enumConstants"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:770:1: enumConstants : enumConstant ( COMMA enumConstant )* ;
    public final void enumConstants() throws RecognitionException {
        int enumConstants_StartIndex = input.index();

        Token COMMA52=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:771:5: ( enumConstant ( COMMA enumConstant )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:771:9: enumConstant ( COMMA enumConstant )*
            {
            pushFollow(FOLLOW_enumConstant_in_enumConstants1476);
            enumConstant();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:772:9: ( COMMA enumConstant )*
            loop29:
            do {
                int alt29=2;
                int LA29_0 = input.LA(1);

                if ( (LA29_0==COMMA) ) {
                    int LA29_1 = input.LA(2);

                    if ( (LA29_1==IDENTIFIER||LA29_1==MONKEYS_AT) ) {
                        alt29=1;
                    }


                }


                switch (alt29) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:772:10: COMMA enumConstant
            	    {
            	    COMMA52=(Token)match(input,COMMA,FOLLOW_COMMA_in_enumConstants1487); if (state.failed) return ;

            	    pushFollow(FOLLOW_enumConstant_in_enumConstants1489);
            	    enumConstant();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(COMMA52); }

            	    }
            	    break;

            	default :
            	    break loop29;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 17, enumConstants_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "enumConstants"



    // $ANTLR start "enumConstant"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:780:1: enumConstant : ( annotations )? IDENTIFIER ( arguments )? ( classBody )? ;
    public final void enumConstant() throws RecognitionException {
        int enumConstant_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:781:5: ( ( annotations )? IDENTIFIER ( arguments )? ( classBody )? )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:781:9: ( annotations )? IDENTIFIER ( arguments )? ( classBody )?
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:781:9: ( annotations )?
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( (LA30_0==MONKEYS_AT) ) {
                alt30=1;
            }
            switch (alt30) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:781:10: annotations
                    {
                    pushFollow(FOLLOW_annotations_in_enumConstant1525);
                    annotations();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumConstant1546); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:784:9: ( arguments )?
            int alt31=2;
            int LA31_0 = input.LA(1);

            if ( (LA31_0==LPAREN) ) {
                alt31=1;
            }
            switch (alt31) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:784:10: arguments
                    {
                    pushFollow(FOLLOW_arguments_in_enumConstant1557);
                    arguments();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:786:9: ( classBody )?
            int alt32=2;
            int LA32_0 = input.LA(1);

            if ( (LA32_0==LBRACE) ) {
                alt32=1;
            }
            switch (alt32) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:786:10: classBody
                    {
                    pushFollow(FOLLOW_classBody_in_enumConstant1579);
                    classBody();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 18, enumConstant_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "enumConstant"



    // $ANTLR start "enumBodyDeclarations"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:792:1: enumBodyDeclarations : SEMI ( classBodyDeclaration )* ;
    public final void enumBodyDeclarations() throws RecognitionException {
        int enumBodyDeclarations_StartIndex = input.index();

        Token SEMI53=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:793:5: ( SEMI ( classBodyDeclaration )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:793:9: SEMI ( classBodyDeclaration )*
            {
            SEMI53=(Token)match(input,SEMI,FOLLOW_SEMI_in_enumBodyDeclarations1620); if (state.failed) return ;

            if ( state.backtracking==0 ) { usb(SEMI53); }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:794:9: ( classBodyDeclaration )*
            loop33:
            do {
                int alt33=2;
                int LA33_0 = input.LA(1);

                if ( (LA33_0==ABSTRACT||LA33_0==BOOLEAN||LA33_0==BYTE||LA33_0==CHAR||LA33_0==CLASS||LA33_0==DOUBLE||LA33_0==ENUM||LA33_0==FINAL||LA33_0==FLOAT||LA33_0==IDENTIFIER||(LA33_0 >= INT && LA33_0 <= INTERFACE)||LA33_0==LBRACE||LA33_0==LONG||LA33_0==LT||(LA33_0 >= MONKEYS_AT && LA33_0 <= NATIVE)||(LA33_0 >= PRIVATE && LA33_0 <= PUBLIC)||(LA33_0 >= SEMI && LA33_0 <= SHORT)||(LA33_0 >= STATIC && LA33_0 <= STRICTFP)||LA33_0==SYNCHRONIZED||LA33_0==TRANSIENT||(LA33_0 >= VOID && LA33_0 <= VOLATILE)) ) {
                    alt33=1;
                }


                switch (alt33) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:794:10: classBodyDeclaration
            	    {
            	    pushFollow(FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1633);
            	    classBodyDeclaration();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop33;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 19, enumBodyDeclarations_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "enumBodyDeclarations"


    protected static class interfaceDeclaration_scope {
        Token first;
    }
    protected Stack interfaceDeclaration_stack = new Stack();


    public static class interfaceDeclaration_return extends ParserRuleReturnScope {
    };


    // $ANTLR start "interfaceDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:798:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration );
    public final JavaTypoParser.interfaceDeclaration_return interfaceDeclaration() throws RecognitionException {
        interfaceDeclaration_stack.push(new interfaceDeclaration_scope());
        JavaTypoParser.interfaceDeclaration_return retval = new JavaTypoParser.interfaceDeclaration_return();
        retval.start = input.LT(1);

        int interfaceDeclaration_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return retval; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:802:5: ( normalInterfaceDeclaration | annotationTypeDeclaration )
            int alt34=2;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA34_1 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA34_2 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA34_3 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA34_4 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA34_5 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA34_6 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA34_7 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA34_8 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA34_9 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA34_10 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA34_11 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA34_12 = input.LA(2);

                if ( (synpred56_JavaTypo()) ) {
                    alt34=1;
                }
                else if ( (true) ) {
                    alt34=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 34, 12, input);

                    throw nvae;

                }
                }
                break;
            case INTERFACE:
                {
                alt34=1;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 34, 0, input);

                throw nvae;

            }

            switch (alt34) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:802:9: normalInterfaceDeclaration
                    {
                    pushFollow(FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1668);
                    normalInterfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:803:9: annotationTypeDeclaration
                    {
                    pushFollow(FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1678);
                    annotationTypeDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;

                    }
                    break;

            }
            retval.stop = input.LT(-1);


        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 20, interfaceDeclaration_StartIndex); }

            interfaceDeclaration_stack.pop();
        }
        return retval;
    }
    // $ANTLR end "interfaceDeclaration"



    // $ANTLR start "normalInterfaceDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:806:1: normalInterfaceDeclaration : ( annotations )? mods INTERFACE IDENTIFIER ( typeParameters )? ( EXTENDS typeList )? interfaceBody ;
    public final void normalInterfaceDeclaration() throws RecognitionException {
        int normalInterfaceDeclaration_StartIndex = input.index();

        Token EXTENDS54=null;
        Token INTERFACE56=null;
        Token IDENTIFIER57=null;
        JavaTypoParser.mods_return mods55 =null;


        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:807:5: ( ( annotations )? mods INTERFACE IDENTIFIER ( typeParameters )? ( EXTENDS typeList )? interfaceBody )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:807:9: ( annotations )? mods INTERFACE IDENTIFIER ( typeParameters )? ( EXTENDS typeList )? interfaceBody
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:807:9: ( annotations )?
            int alt35=2;
            int LA35_0 = input.LA(1);

            if ( (LA35_0==MONKEYS_AT) ) {
                alt35=1;
            }
            switch (alt35) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:807:9: annotations
                    {
                    pushFollow(FOLLOW_annotations_in_normalInterfaceDeclaration1702);
                    annotations();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            pushFollow(FOLLOW_mods_in_normalInterfaceDeclaration1705);
            mods55=mods();

            state._fsp--;
            if (state.failed) return ;

            INTERFACE56=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_normalInterfaceDeclaration1707); if (state.failed) return ;

            IDENTIFIER57=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1709); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:808:9: ( typeParameters )?
            int alt36=2;
            int LA36_0 = input.LA(1);

            if ( (LA36_0==LT) ) {
                alt36=1;
            }
            switch (alt36) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:808:10: typeParameters
                    {
                    pushFollow(FOLLOW_typeParameters_in_normalInterfaceDeclaration1720);
                    typeParameters();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:810:9: ( EXTENDS typeList )?
            int alt37=2;
            int LA37_0 = input.LA(1);

            if ( (LA37_0==EXTENDS) ) {
                alt37=1;
            }
            switch (alt37) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:810:10: EXTENDS typeList
                    {
                    EXTENDS54=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_normalInterfaceDeclaration1742); if (state.failed) return ;

                    pushFollow(FOLLOW_typeList_in_normalInterfaceDeclaration1744);
                    typeList();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(EXTENDS54); }

                    }
                    break;

            }


            if ( state.backtracking==0 ) { ((interfaceDeclaration_scope)interfaceDeclaration_stack.peek()).first = (mods55!=null?((Token)mods55.start):null); }

            pushFollow(FOLLOW_interfaceBody_in_normalInterfaceDeclaration1777);
            interfaceBody();

            state._fsp--;
            if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(INTERFACE56); results.addClassInterfaceName((IDENTIFIER57!=null?IDENTIFIER57.getText():null), getStart(IDENTIFIER57), (IDENTIFIER57!=null?IDENTIFIER57.getLine():0), (IDENTIFIER57!=null?IDENTIFIER57.getCharPositionInLine():0)); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 21, normalInterfaceDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "normalInterfaceDeclaration"



    // $ANTLR start "typeList"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:817:1: typeList : type ( COMMA type )* ;
    public final void typeList() throws RecognitionException {
        int typeList_StartIndex = input.index();

        Token COMMA58=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:818:5: ( type ( COMMA type )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:818:9: type ( COMMA type )*
            {
            pushFollow(FOLLOW_type_in_typeList1807);
            type();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:819:9: ( COMMA type )*
            loop38:
            do {
                int alt38=2;
                int LA38_0 = input.LA(1);

                if ( (LA38_0==COMMA) ) {
                    alt38=1;
                }


                switch (alt38) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:819:10: COMMA type
            	    {
            	    COMMA58=(Token)match(input,COMMA,FOLLOW_COMMA_in_typeList1818); if (state.failed) return ;

            	    pushFollow(FOLLOW_type_in_typeList1820);
            	    type();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(COMMA58); }

            	    }
            	    break;

            	default :
            	    break loop38;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 22, typeList_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "typeList"


    public static class classBody_return extends ParserRuleReturnScope {
    };


    // $ANTLR start "classBody"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:823:1: classBody : LBRACE ( classBodyDeclaration )* RBRACE ;
    public final JavaTypoParser.classBody_return classBody() throws RecognitionException {
        JavaTypoParser.classBody_return retval = new JavaTypoParser.classBody_return();
        retval.start = input.LT(1);

        int classBody_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return retval; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:824:5: ( LBRACE ( classBodyDeclaration )* RBRACE )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:824:9: LBRACE ( classBodyDeclaration )* RBRACE
            {
            match(input,LBRACE,FOLLOW_LBRACE_in_classBody1853); if (state.failed) return retval;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:825:9: ( classBodyDeclaration )*
            loop39:
            do {
                int alt39=2;
                int LA39_0 = input.LA(1);

                if ( (LA39_0==ABSTRACT||LA39_0==BOOLEAN||LA39_0==BYTE||LA39_0==CHAR||LA39_0==CLASS||LA39_0==DOUBLE||LA39_0==ENUM||LA39_0==FINAL||LA39_0==FLOAT||LA39_0==IDENTIFIER||(LA39_0 >= INT && LA39_0 <= INTERFACE)||LA39_0==LBRACE||LA39_0==LONG||LA39_0==LT||(LA39_0 >= MONKEYS_AT && LA39_0 <= NATIVE)||(LA39_0 >= PRIVATE && LA39_0 <= PUBLIC)||(LA39_0 >= SEMI && LA39_0 <= SHORT)||(LA39_0 >= STATIC && LA39_0 <= STRICTFP)||LA39_0==SYNCHRONIZED||LA39_0==TRANSIENT||(LA39_0 >= VOID && LA39_0 <= VOLATILE)) ) {
                    alt39=1;
                }


                switch (alt39) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:825:10: classBodyDeclaration
            	    {
            	    pushFollow(FOLLOW_classBodyDeclaration_in_classBody1865);
            	    classBodyDeclaration();

            	    state._fsp--;
            	    if (state.failed) return retval;

            	    }
            	    break;

            	default :
            	    break loop39;
                }
            } while (true);


            match(input,RBRACE,FOLLOW_RBRACE_in_classBody1887); if (state.failed) return retval;

            }

            retval.stop = input.LT(-1);


        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 23, classBody_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "classBody"



    // $ANTLR start "interfaceBody"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:830:1: interfaceBody : LBRACE ( interfaceBodyDeclaration )* RBRACE ;
    public final void interfaceBody() throws RecognitionException {
        int interfaceBody_StartIndex = input.index();

        Token LBRACE59=null;
        Token RBRACE60=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:831:5: ( LBRACE ( interfaceBodyDeclaration )* RBRACE )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:831:9: LBRACE ( interfaceBodyDeclaration )* RBRACE
            {
            LBRACE59=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_interfaceBody1907); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:832:9: ( interfaceBodyDeclaration )*
            loop40:
            do {
                int alt40=2;
                int LA40_0 = input.LA(1);

                if ( (LA40_0==ABSTRACT||LA40_0==BOOLEAN||LA40_0==BYTE||LA40_0==CHAR||LA40_0==CLASS||LA40_0==DOUBLE||LA40_0==ENUM||LA40_0==FINAL||LA40_0==FLOAT||LA40_0==IDENTIFIER||(LA40_0 >= INT && LA40_0 <= INTERFACE)||LA40_0==LONG||LA40_0==LT||(LA40_0 >= MONKEYS_AT && LA40_0 <= NATIVE)||(LA40_0 >= PRIVATE && LA40_0 <= PUBLIC)||(LA40_0 >= SEMI && LA40_0 <= SHORT)||(LA40_0 >= STATIC && LA40_0 <= STRICTFP)||LA40_0==SYNCHRONIZED||LA40_0==TRANSIENT||(LA40_0 >= VOID && LA40_0 <= VOLATILE)) ) {
                    alt40=1;
                }


                switch (alt40) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:832:10: interfaceBodyDeclaration
            	    {
            	    pushFollow(FOLLOW_interfaceBodyDeclaration_in_interfaceBody1919);
            	    interfaceBodyDeclaration();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop40;
                }
            } while (true);


            RBRACE60=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_interfaceBody1941); if (state.failed) return ;

            if ( state.backtracking==0 ) { updateBrace(((interfaceDeclaration_scope)interfaceDeclaration_stack.peek()).first, LBRACE59, RBRACE60); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 24, interfaceBody_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "interfaceBody"



    // $ANTLR start "classBodyDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:838:1: classBodyDeclaration : ( SEMI | STATIC block | block | memberDecl );
    public final void classBodyDeclaration() throws RecognitionException {
        int classBodyDeclaration_StartIndex = input.index();

        Token SEMI61=null;
        Token STATIC62=null;
        JavaTypoParser.block_return block63 =null;


        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:839:5: ( SEMI | STATIC block | block | memberDecl )
            int alt41=4;
            switch ( input.LA(1) ) {
            case SEMI:
                {
                alt41=1;
                }
                break;
            case STATIC:
                {
                int LA41_2 = input.LA(2);

                if ( (LA41_2==LBRACE) ) {
                    alt41=2;
                }
                else if ( (LA41_2==ABSTRACT||LA41_2==BOOLEAN||LA41_2==BYTE||LA41_2==CHAR||LA41_2==CLASS||LA41_2==DOUBLE||LA41_2==ENUM||LA41_2==FINAL||LA41_2==FLOAT||LA41_2==IDENTIFIER||(LA41_2 >= INT && LA41_2 <= INTERFACE)||LA41_2==LONG||LA41_2==LT||(LA41_2 >= MONKEYS_AT && LA41_2 <= NATIVE)||(LA41_2 >= PRIVATE && LA41_2 <= PUBLIC)||LA41_2==SHORT||(LA41_2 >= STATIC && LA41_2 <= STRICTFP)||LA41_2==SYNCHRONIZED||LA41_2==TRANSIENT||(LA41_2 >= VOID && LA41_2 <= VOLATILE)) ) {
                    alt41=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 41, 2, input);

                    throw nvae;

                }
                }
                break;
            case LBRACE:
                {
                alt41=3;
                }
                break;
            case ABSTRACT:
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CLASS:
            case DOUBLE:
            case ENUM:
            case FINAL:
            case FLOAT:
            case IDENTIFIER:
            case INT:
            case INTERFACE:
            case LONG:
            case LT:
            case MONKEYS_AT:
            case NATIVE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case SHORT:
            case STRICTFP:
            case SYNCHRONIZED:
            case TRANSIENT:
            case VOID:
            case VOLATILE:
                {
                alt41=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 41, 0, input);

                throw nvae;

            }

            switch (alt41) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:839:9: SEMI
                    {
                    SEMI61=(Token)match(input,SEMI,FOLLOW_SEMI_in_classBodyDeclaration1971); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(SEMI61); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:840:9: STATIC block
                    {
                    STATIC62=(Token)match(input,STATIC,FOLLOW_STATIC_in_classBodyDeclaration1983); if (state.failed) return ;

                    pushFollow(FOLLOW_block_in_classBodyDeclaration1993);
                    block63=block();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) {  updateBrace(STATIC62, (block63!=null?((Token)block63.start):null), (block63!=null?((Token)block63.stop):null)); usa(STATIC62); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:843:9: block
                    {
                    pushFollow(FOLLOW_block_in_classBodyDeclaration2014);
                    block();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:844:9: memberDecl
                    {
                    pushFollow(FOLLOW_memberDecl_in_classBodyDeclaration2024);
                    memberDecl();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 25, classBodyDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "classBodyDeclaration"



    // $ANTLR start "memberDecl"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:847:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration );
    public final void memberDecl() throws RecognitionException {
        int memberDecl_StartIndex = input.index();

        JavaTypoParser.fieldDeclaration_return fieldDeclaration64 =null;

        JavaTypoParser.methodDeclaration_return methodDeclaration65 =null;

        JavaTypoParser.classDeclaration_return classDeclaration66 =null;

        JavaTypoParser.interfaceDeclaration_return interfaceDeclaration67 =null;


        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:848:5: ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration )
            int alt42=4;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA42_1 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA42_2 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA42_3 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA42_4 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA42_5 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA42_6 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA42_7 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA42_8 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA42_9 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA42_10 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA42_11 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA42_12 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else if ( (synpred68_JavaTypo()) ) {
                    alt42=3;
                }
                else if ( (true) ) {
                    alt42=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 12, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA42_13 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 13, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
                {
                int LA42_14 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 14, input);

                    throw nvae;

                }
                }
                break;
            case CHAR:
                {
                int LA42_15 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 15, input);

                    throw nvae;

                }
                }
                break;
            case BYTE:
                {
                int LA42_16 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 16, input);

                    throw nvae;

                }
                }
                break;
            case SHORT:
                {
                int LA42_17 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 17, input);

                    throw nvae;

                }
                }
                break;
            case INT:
                {
                int LA42_18 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 18, input);

                    throw nvae;

                }
                }
                break;
            case LONG:
                {
                int LA42_19 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 19, input);

                    throw nvae;

                }
                }
                break;
            case FLOAT:
                {
                int LA42_20 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 20, input);

                    throw nvae;

                }
                }
                break;
            case DOUBLE:
                {
                int LA42_21 = input.LA(2);

                if ( (synpred66_JavaTypo()) ) {
                    alt42=1;
                }
                else if ( (synpred67_JavaTypo()) ) {
                    alt42=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 21, input);

                    throw nvae;

                }
                }
                break;
            case LT:
            case VOID:
                {
                alt42=2;
                }
                break;
            case CLASS:
            case ENUM:
                {
                alt42=3;
                }
                break;
            case INTERFACE:
                {
                alt42=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 42, 0, input);

                throw nvae;

            }

            switch (alt42) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:848:10: fieldDeclaration
                    {
                    pushFollow(FOLLOW_fieldDeclaration_in_memberDecl2045);
                    fieldDeclaration64=fieldDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { addStart(TypoResults.RangeType.FIELD_START, (fieldDeclaration64!=null?((Token)fieldDeclaration64.start):null)); addStop(TypoResults.RangeType.FIELD_END, (fieldDeclaration64!=null?((Token)fieldDeclaration64.stop):null)); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:849:10: methodDeclaration
                    {
                    pushFollow(FOLLOW_methodDeclaration_in_memberDecl2058);
                    methodDeclaration65=methodDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { addStart(TypoResults.RangeType.METHOD_START, (methodDeclaration65!=null?((Token)methodDeclaration65.start):null)); addStop(TypoResults.RangeType.METHOD_END, (methodDeclaration65!=null?((Token)methodDeclaration65.stop):null)); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:850:10: classDeclaration
                    {
                    pushFollow(FOLLOW_classDeclaration_in_memberDecl2071);
                    classDeclaration66=classDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { addStart(TypoResults.RangeType.TYPE_DECL_START, (classDeclaration66!=null?((Token)classDeclaration66.start):null)); addStop(TypoResults.RangeType.TYPE_DECL_END, (classDeclaration66!=null?((Token)classDeclaration66.stop):null)); }

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:851:10: interfaceDeclaration
                    {
                    pushFollow(FOLLOW_interfaceDeclaration_in_memberDecl2084);
                    interfaceDeclaration67=interfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { addStart(TypoResults.RangeType.TYPE_DECL_START, (interfaceDeclaration67!=null?((Token)interfaceDeclaration67.start):null)); addStop(TypoResults.RangeType.TYPE_DECL_END, (interfaceDeclaration67!=null?((Token)interfaceDeclaration67.stop):null)); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 26, memberDecl_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "memberDecl"


    public static class methodDeclaration_return extends ParserRuleReturnScope {
    };


    // $ANTLR start "methodDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:855:1: methodDeclaration : ( ( annotations )? mods ( typeParameters )? IDENTIFIER formalParameters ( THROWS qualifiedNameList )? a= '{' ( explicitConstructorInvocation )? ( blockStatement )* b= '}' | ( annotations )? mods ( typeParameters )? ( type | VOID ) IDENTIFIER formalParameters ( LBRACKET RBRACKET )* ( THROWS qualifiedNameList )? ( block | SEMI ) );
    public final JavaTypoParser.methodDeclaration_return methodDeclaration() throws RecognitionException {
        JavaTypoParser.methodDeclaration_return retval = new JavaTypoParser.methodDeclaration_return();
        retval.start = input.LT(1);

        int methodDeclaration_StartIndex = input.index();

        Token a=null;
        Token b=null;
        Token THROWS68=null;
        Token IDENTIFIER70=null;
        Token VOID71=null;
        Token LBRACKET72=null;
        Token RBRACKET73=null;
        Token THROWS74=null;
        Token IDENTIFIER77=null;
        Token SEMI78=null;
        JavaTypoParser.mods_return mods69 =null;

        JavaTypoParser.mods_return mods75 =null;

        JavaTypoParser.block_return block76 =null;


        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return retval; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:856:5: ( ( annotations )? mods ( typeParameters )? IDENTIFIER formalParameters ( THROWS qualifiedNameList )? a= '{' ( explicitConstructorInvocation )? ( blockStatement )* b= '}' | ( annotations )? mods ( typeParameters )? ( type | VOID ) IDENTIFIER formalParameters ( LBRACKET RBRACKET )* ( THROWS qualifiedNameList )? ( block | SEMI ) )
            int alt54=2;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA54_1 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA54_2 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA54_3 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA54_4 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA54_5 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA54_6 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA54_7 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA54_8 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA54_9 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA54_10 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA54_11 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA54_12 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 12, input);

                    throw nvae;

                }
                }
                break;
            case LT:
                {
                int LA54_13 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 13, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA54_14 = input.LA(2);

                if ( (synpred74_JavaTypo()) ) {
                    alt54=1;
                }
                else if ( (true) ) {
                    alt54=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 54, 14, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
            case VOID:
                {
                alt54=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 54, 0, input);

                throw nvae;

            }

            switch (alt54) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:858:9: ( annotations )? mods ( typeParameters )? IDENTIFIER formalParameters ( THROWS qualifiedNameList )? a= '{' ( explicitConstructorInvocation )? ( blockStatement )* b= '}'
                    {
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:858:9: ( annotations )?
                    int alt43=2;
                    int LA43_0 = input.LA(1);

                    if ( (LA43_0==MONKEYS_AT) ) {
                        alt43=1;
                    }
                    switch (alt43) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:858:9: annotations
                            {
                            pushFollow(FOLLOW_annotations_in_methodDeclaration2123);
                            annotations();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;

                    }


                    pushFollow(FOLLOW_mods_in_methodDeclaration2126);
                    mods69=mods();

                    state._fsp--;
                    if (state.failed) return retval;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:859:9: ( typeParameters )?
                    int alt44=2;
                    int LA44_0 = input.LA(1);

                    if ( (LA44_0==LT) ) {
                        alt44=1;
                    }
                    switch (alt44) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:859:10: typeParameters
                            {
                            pushFollow(FOLLOW_typeParameters_in_methodDeclaration2137);
                            typeParameters();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;

                    }


                    IDENTIFIER70=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration2158); if (state.failed) return retval;

                    pushFollow(FOLLOW_formalParameters_in_methodDeclaration2168);
                    formalParameters();

                    state._fsp--;
                    if (state.failed) return retval;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:863:9: ( THROWS qualifiedNameList )?
                    int alt45=2;
                    int LA45_0 = input.LA(1);

                    if ( (LA45_0==THROWS) ) {
                        alt45=1;
                    }
                    switch (alt45) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:863:10: THROWS qualifiedNameList
                            {
                            THROWS68=(Token)match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration2179); if (state.failed) return retval;

                            pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration2181);
                            qualifiedNameList();

                            state._fsp--;
                            if (state.failed) return retval;

                            if ( state.backtracking==0 ) { usa(THROWS68); }

                            }
                            break;

                    }


                    a=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_methodDeclaration2206); if (state.failed) return retval;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:866:9: ( explicitConstructorInvocation )?
                    int alt46=2;
                    switch ( input.LA(1) ) {
                        case LT:
                            {
                            alt46=1;
                            }
                            break;
                        case THIS:
                            {
                            int LA46_2 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case SUPER:
                            {
                            int LA46_3 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case LPAREN:
                            {
                            int LA46_4 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case IDENTIFIER:
                            {
                            int LA46_5 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case CHARLITERAL:
                        case DOUBLELITERAL:
                        case FALSE:
                        case FLOATLITERAL:
                        case INTLITERAL:
                        case LONGLITERAL:
                        case NULL:
                        case STRINGLITERAL:
                        case TRUE:
                            {
                            int LA46_6 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case NEW:
                            {
                            int LA46_7 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case BOOLEAN:
                            {
                            int LA46_8 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case CHAR:
                            {
                            int LA46_9 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case BYTE:
                            {
                            int LA46_10 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case SHORT:
                            {
                            int LA46_11 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case INT:
                            {
                            int LA46_12 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case LONG:
                            {
                            int LA46_13 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case FLOAT:
                            {
                            int LA46_14 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case DOUBLE:
                            {
                            int LA46_15 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                        case VOID:
                            {
                            int LA46_16 = input.LA(2);

                            if ( (synpred72_JavaTypo()) ) {
                                alt46=1;
                            }
                            }
                            break;
                    }

                    switch (alt46) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:866:10: explicitConstructorInvocation
                            {
                            pushFollow(FOLLOW_explicitConstructorInvocation_in_methodDeclaration2218);
                            explicitConstructorInvocation();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;

                    }


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:868:9: ( blockStatement )*
                    loop47:
                    do {
                        int alt47=2;
                        int LA47_0 = input.LA(1);

                        if ( (LA47_0==ABSTRACT||(LA47_0 >= ASSERT && LA47_0 <= BANG)||(LA47_0 >= BOOLEAN && LA47_0 <= BYTE)||(LA47_0 >= CHAR && LA47_0 <= CLASS)||LA47_0==CONTINUE||LA47_0==DO||(LA47_0 >= DOUBLE && LA47_0 <= DOUBLELITERAL)||LA47_0==ENUM||(LA47_0 >= FALSE && LA47_0 <= FINAL)||(LA47_0 >= FLOAT && LA47_0 <= FOR)||(LA47_0 >= IDENTIFIER && LA47_0 <= IF)||(LA47_0 >= INT && LA47_0 <= INTLITERAL)||LA47_0==LBRACE||(LA47_0 >= LONG && LA47_0 <= LT)||(LA47_0 >= MONKEYS_AT && LA47_0 <= NULL)||LA47_0==PLUS||(LA47_0 >= PLUSPLUS && LA47_0 <= PUBLIC)||LA47_0==RETURN||(LA47_0 >= SEMI && LA47_0 <= SHORT)||(LA47_0 >= STATIC && LA47_0 <= SUB)||(LA47_0 >= SUBSUB && LA47_0 <= SYNCHRONIZED)||(LA47_0 >= THIS && LA47_0 <= THROW)||(LA47_0 >= TILDE && LA47_0 <= WHILE)) ) {
                            alt47=1;
                        }


                        switch (alt47) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:868:10: blockStatement
                    	    {
                    	    pushFollow(FOLLOW_blockStatement_in_methodDeclaration2240);
                    	    blockStatement();

                    	    state._fsp--;
                    	    if (state.failed) return retval;

                    	    }
                    	    break;

                    	default :
                    	    break loop47;
                        }
                    } while (true);


                    b=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_methodDeclaration2263); if (state.failed) return retval;

                    if ( state.backtracking==0 ) { 
                              updateBrace((mods69!=null?((Token)mods69.start):null), a, b); 
                              results.addMethodLength((IDENTIFIER70!=null?IDENTIFIER70.getText():null), (a!=null?a.getLine():0), (b!=null?b.getLine():0)); 
                              addConstructor(IDENTIFIER70);
                            }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:876:9: ( annotations )? mods ( typeParameters )? ( type | VOID ) IDENTIFIER formalParameters ( LBRACKET RBRACKET )* ( THROWS qualifiedNameList )? ( block | SEMI )
                    {
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:876:9: ( annotations )?
                    int alt48=2;
                    int LA48_0 = input.LA(1);

                    if ( (LA48_0==MONKEYS_AT) ) {
                        alt48=1;
                    }
                    switch (alt48) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:876:9: annotations
                            {
                            pushFollow(FOLLOW_annotations_in_methodDeclaration2283);
                            annotations();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;

                    }


                    pushFollow(FOLLOW_mods_in_methodDeclaration2286);
                    mods75=mods();

                    state._fsp--;
                    if (state.failed) return retval;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:877:9: ( typeParameters )?
                    int alt49=2;
                    int LA49_0 = input.LA(1);

                    if ( (LA49_0==LT) ) {
                        alt49=1;
                    }
                    switch (alt49) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:877:10: typeParameters
                            {
                            pushFollow(FOLLOW_typeParameters_in_methodDeclaration2297);
                            typeParameters();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;

                    }


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:879:9: ( type | VOID )
                    int alt50=2;
                    int LA50_0 = input.LA(1);

                    if ( (LA50_0==BOOLEAN||LA50_0==BYTE||LA50_0==CHAR||LA50_0==DOUBLE||LA50_0==FLOAT||LA50_0==IDENTIFIER||LA50_0==INT||LA50_0==LONG||LA50_0==SHORT) ) {
                        alt50=1;
                    }
                    else if ( (LA50_0==VOID) ) {
                        alt50=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 50, 0, input);

                        throw nvae;

                    }
                    switch (alt50) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:879:10: type
                            {
                            pushFollow(FOLLOW_type_in_methodDeclaration2319);
                            type();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:880:13: VOID
                            {
                            VOID71=(Token)match(input,VOID,FOLLOW_VOID_in_methodDeclaration2333); if (state.failed) return retval;

                            if ( state.backtracking==0 ) { usa(VOID71); }

                            }
                            break;

                    }


                    IDENTIFIER77=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration2356); if (state.failed) return retval;

                    pushFollow(FOLLOW_formalParameters_in_methodDeclaration2366);
                    formalParameters();

                    state._fsp--;
                    if (state.failed) return retval;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:884:9: ( LBRACKET RBRACKET )*
                    loop51:
                    do {
                        int alt51=2;
                        int LA51_0 = input.LA(1);

                        if ( (LA51_0==LBRACKET) ) {
                            alt51=1;
                        }


                        switch (alt51) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:884:10: LBRACKET RBRACKET
                    	    {
                    	    LBRACKET72=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_methodDeclaration2377); if (state.failed) return retval;

                    	    RBRACKET73=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_methodDeclaration2379); if (state.failed) return retval;

                    	    if ( state.backtracking==0 ) { usa(LBRACKET72); usb(RBRACKET73); }

                    	    }
                    	    break;

                    	default :
                    	    break loop51;
                        }
                    } while (true);


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:886:9: ( THROWS qualifiedNameList )?
                    int alt52=2;
                    int LA52_0 = input.LA(1);

                    if ( (LA52_0==THROWS) ) {
                        alt52=1;
                    }
                    switch (alt52) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:886:10: THROWS qualifiedNameList
                            {
                            THROWS74=(Token)match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration2403); if (state.failed) return retval;

                            pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration2405);
                            qualifiedNameList();

                            state._fsp--;
                            if (state.failed) return retval;

                            if ( state.backtracking==0 ) { usa(THROWS74); }

                            }
                            break;

                    }


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:888:9: ( block | SEMI )
                    int alt53=2;
                    int LA53_0 = input.LA(1);

                    if ( (LA53_0==LBRACE) ) {
                        alt53=1;
                    }
                    else if ( (LA53_0==SEMI) ) {
                        alt53=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 53, 0, input);

                        throw nvae;

                    }
                    switch (alt53) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:889:13: block
                            {
                            pushFollow(FOLLOW_block_in_methodDeclaration2462);
                            block76=block();

                            state._fsp--;
                            if (state.failed) return retval;

                            if ( state.backtracking==0 ) {  updateBrace((mods75!=null?((Token)mods75.start):null), (block76!=null?((Token)block76.start):null), (block76!=null?((Token)block76.stop):null)); results.addMethodLength((IDENTIFIER77!=null?IDENTIFIER77.getText():null), (block76!=null?((Token)block76.start):null).getLine(), (block76!=null?((Token)block76.stop):null).getLine()); }

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:890:13: SEMI
                            {
                            SEMI78=(Token)match(input,SEMI,FOLLOW_SEMI_in_methodDeclaration2478); if (state.failed) return retval;

                            if ( state.backtracking==0 ) { usb(SEMI78); }

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { results.addMethodName((IDENTIFIER77!=null?IDENTIFIER77.getText():null), getStart(IDENTIFIER77), (IDENTIFIER77!=null?IDENTIFIER77.getLine():0), (IDENTIFIER77!=null?IDENTIFIER77.getCharPositionInLine():0)); }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 27, methodDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "methodDeclaration"


    public static class fieldDeclaration_return extends ParserRuleReturnScope {
    };


    // $ANTLR start "fieldDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:896:1: fieldDeclaration : modifiers type variableDeclarator ( COMMA variableDeclarator )* SEMI ;
    public final JavaTypoParser.fieldDeclaration_return fieldDeclaration() throws RecognitionException {
        JavaTypoParser.fieldDeclaration_return retval = new JavaTypoParser.fieldDeclaration_return();
        retval.start = input.LT(1);

        int fieldDeclaration_StartIndex = input.index();

        Token COMMA79=null;
        Token SEMI80=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return retval; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:897:5: ( modifiers type variableDeclarator ( COMMA variableDeclarator )* SEMI )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:897:9: modifiers type variableDeclarator ( COMMA variableDeclarator )* SEMI
            {
            pushFollow(FOLLOW_modifiers_in_fieldDeclaration2521);
            modifiers();

            state._fsp--;
            if (state.failed) return retval;

            pushFollow(FOLLOW_type_in_fieldDeclaration2531);
            type();

            state._fsp--;
            if (state.failed) return retval;

            pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2541);
            variableDeclarator();

            state._fsp--;
            if (state.failed) return retval;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:900:9: ( COMMA variableDeclarator )*
            loop55:
            do {
                int alt55=2;
                int LA55_0 = input.LA(1);

                if ( (LA55_0==COMMA) ) {
                    alt55=1;
                }


                switch (alt55) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:900:10: COMMA variableDeclarator
            	    {
            	    COMMA79=(Token)match(input,COMMA,FOLLOW_COMMA_in_fieldDeclaration2552); if (state.failed) return retval;

            	    pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2554);
            	    variableDeclarator();

            	    state._fsp--;
            	    if (state.failed) return retval;

            	    if ( state.backtracking==0 ) { usc(COMMA79); }

            	    }
            	    break;

            	default :
            	    break loop55;
                }
            } while (true);


            SEMI80=(Token)match(input,SEMI,FOLLOW_SEMI_in_fieldDeclaration2577); if (state.failed) return retval;

            if ( state.backtracking==0 ) { usb(SEMI80); addStmt((SEMI80!=null?SEMI80.getLine():0)); isStatic = isFinal = false; }

            }

            retval.stop = input.LT(-1);


        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 28, fieldDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "fieldDeclaration"



    // $ANTLR start "variableDeclarator"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:905:1: variableDeclarator : IDENTIFIER ( LBRACKET RBRACKET )* ( EQ variableInitializer )? ;
    public final void variableDeclarator() throws RecognitionException {
        int variableDeclarator_StartIndex = input.index();

        Token LBRACKET81=null;
        Token RBRACKET82=null;
        Token EQ83=null;
        Token IDENTIFIER84=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:906:5: ( IDENTIFIER ( LBRACKET RBRACKET )* ( EQ variableInitializer )? )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:906:9: IDENTIFIER ( LBRACKET RBRACKET )* ( EQ variableInitializer )?
            {
            IDENTIFIER84=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variableDeclarator2599); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:907:9: ( LBRACKET RBRACKET )*
            loop56:
            do {
                int alt56=2;
                int LA56_0 = input.LA(1);

                if ( (LA56_0==LBRACKET) ) {
                    alt56=1;
                }


                switch (alt56) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:907:10: LBRACKET RBRACKET
            	    {
            	    LBRACKET81=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_variableDeclarator2610); if (state.failed) return ;

            	    RBRACKET82=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_variableDeclarator2612); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(LBRACKET81); usb(RBRACKET82); }

            	    }
            	    break;

            	default :
            	    break loop56;
                }
            } while (true);


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:909:9: ( EQ variableInitializer )?
            int alt57=2;
            int LA57_0 = input.LA(1);

            if ( (LA57_0==EQ) ) {
                alt57=1;
            }
            switch (alt57) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:909:10: EQ variableInitializer
                    {
                    EQ83=(Token)match(input,EQ,FOLLOW_EQ_in_variableDeclarator2636); if (state.failed) return ;

                    pushFollow(FOLLOW_variableInitializer_in_variableDeclarator2638);
                    variableInitializer();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(EQ83); }

                    }
                    break;

            }


            if ( state.backtracking==0 ) { 
                    	if (isStatic && isFinal)
                    		results.addConstantName((IDENTIFIER84!=null?IDENTIFIER84.getText():null), getStart(IDENTIFIER84), (IDENTIFIER84!=null?IDENTIFIER84.getLine():0), (IDENTIFIER84!=null?IDENTIFIER84.getCharPositionInLine():0));
                    	else
                            	results.addVariableName((IDENTIFIER84!=null?IDENTIFIER84.getText():null), getStart(IDENTIFIER84), (IDENTIFIER84!=null?IDENTIFIER84.getLine():0), (IDENTIFIER84!=null?IDENTIFIER84.getCharPositionInLine():0)); 
                    }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 29, variableDeclarator_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "variableDeclarator"



    // $ANTLR start "interfaceBodyDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:922:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | SEMI );
    public final void interfaceBodyDeclaration() throws RecognitionException {
        int interfaceBodyDeclaration_StartIndex = input.index();

        Token SEMI85=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:923:5: ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | SEMI )
            int alt58=5;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA58_1 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA58_2 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA58_3 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA58_4 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA58_5 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA58_6 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA58_7 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA58_8 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA58_9 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA58_10 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA58_11 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA58_12 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else if ( (synpred86_JavaTypo()) ) {
                    alt58=3;
                }
                else if ( (synpred87_JavaTypo()) ) {
                    alt58=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 12, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA58_13 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 13, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
                {
                int LA58_14 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 14, input);

                    throw nvae;

                }
                }
                break;
            case CHAR:
                {
                int LA58_15 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 15, input);

                    throw nvae;

                }
                }
                break;
            case BYTE:
                {
                int LA58_16 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 16, input);

                    throw nvae;

                }
                }
                break;
            case SHORT:
                {
                int LA58_17 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 17, input);

                    throw nvae;

                }
                }
                break;
            case INT:
                {
                int LA58_18 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 18, input);

                    throw nvae;

                }
                }
                break;
            case LONG:
                {
                int LA58_19 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 19, input);

                    throw nvae;

                }
                }
                break;
            case FLOAT:
                {
                int LA58_20 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 20, input);

                    throw nvae;

                }
                }
                break;
            case DOUBLE:
                {
                int LA58_21 = input.LA(2);

                if ( (synpred84_JavaTypo()) ) {
                    alt58=1;
                }
                else if ( (synpred85_JavaTypo()) ) {
                    alt58=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 58, 21, input);

                    throw nvae;

                }
                }
                break;
            case LT:
            case VOID:
                {
                alt58=2;
                }
                break;
            case INTERFACE:
                {
                alt58=3;
                }
                break;
            case CLASS:
            case ENUM:
                {
                alt58=4;
                }
                break;
            case SEMI:
                {
                alt58=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 58, 0, input);

                throw nvae;

            }

            switch (alt58) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:924:9: interfaceFieldDeclaration
                    {
                    pushFollow(FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration2689);
                    interfaceFieldDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:925:9: interfaceMethodDeclaration
                    {
                    pushFollow(FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration2699);
                    interfaceMethodDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:926:9: interfaceDeclaration
                    {
                    pushFollow(FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration2709);
                    interfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:927:9: classDeclaration
                    {
                    pushFollow(FOLLOW_classDeclaration_in_interfaceBodyDeclaration2719);
                    classDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:928:9: SEMI
                    {
                    SEMI85=(Token)match(input,SEMI,FOLLOW_SEMI_in_interfaceBodyDeclaration2729); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(SEMI85); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 30, interfaceBodyDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "interfaceBodyDeclaration"



    // $ANTLR start "interfaceMethodDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:931:1: interfaceMethodDeclaration : modifiers ( typeParameters )? ( type | VOID ) IDENTIFIER formalParameters ( LBRACKET RBRACKET )* ( THROWS qualifiedNameList )? SEMI ;
    public final void interfaceMethodDeclaration() throws RecognitionException {
        int interfaceMethodDeclaration_StartIndex = input.index();

        Token VOID86=null;
        Token LBRACKET87=null;
        Token RBRACKET88=null;
        Token THROWS89=null;
        Token SEMI90=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:932:5: ( modifiers ( typeParameters )? ( type | VOID ) IDENTIFIER formalParameters ( LBRACKET RBRACKET )* ( THROWS qualifiedNameList )? SEMI )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:932:9: modifiers ( typeParameters )? ( type | VOID ) IDENTIFIER formalParameters ( LBRACKET RBRACKET )* ( THROWS qualifiedNameList )? SEMI
            {
            pushFollow(FOLLOW_modifiers_in_interfaceMethodDeclaration2751);
            modifiers();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:933:9: ( typeParameters )?
            int alt59=2;
            int LA59_0 = input.LA(1);

            if ( (LA59_0==LT) ) {
                alt59=1;
            }
            switch (alt59) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:933:10: typeParameters
                    {
                    pushFollow(FOLLOW_typeParameters_in_interfaceMethodDeclaration2762);
                    typeParameters();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:935:9: ( type | VOID )
            int alt60=2;
            int LA60_0 = input.LA(1);

            if ( (LA60_0==BOOLEAN||LA60_0==BYTE||LA60_0==CHAR||LA60_0==DOUBLE||LA60_0==FLOAT||LA60_0==IDENTIFIER||LA60_0==INT||LA60_0==LONG||LA60_0==SHORT) ) {
                alt60=1;
            }
            else if ( (LA60_0==VOID) ) {
                alt60=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 60, 0, input);

                throw nvae;

            }
            switch (alt60) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:935:10: type
                    {
                    pushFollow(FOLLOW_type_in_interfaceMethodDeclaration2784);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:936:10: VOID
                    {
                    VOID86=(Token)match(input,VOID,FOLLOW_VOID_in_interfaceMethodDeclaration2795); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(VOID86); }

                    }
                    break;

            }


            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration2817); if (state.failed) return ;

            pushFollow(FOLLOW_formalParameters_in_interfaceMethodDeclaration2827);
            formalParameters();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:940:9: ( LBRACKET RBRACKET )*
            loop61:
            do {
                int alt61=2;
                int LA61_0 = input.LA(1);

                if ( (LA61_0==LBRACKET) ) {
                    alt61=1;
                }


                switch (alt61) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:940:10: LBRACKET RBRACKET
            	    {
            	    LBRACKET87=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_interfaceMethodDeclaration2838); if (state.failed) return ;

            	    RBRACKET88=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_interfaceMethodDeclaration2840); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(LBRACKET87); usb(RBRACKET88); }

            	    }
            	    break;

            	default :
            	    break loop61;
                }
            } while (true);


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:942:9: ( THROWS qualifiedNameList )?
            int alt62=2;
            int LA62_0 = input.LA(1);

            if ( (LA62_0==THROWS) ) {
                alt62=1;
            }
            switch (alt62) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:942:10: THROWS qualifiedNameList
                    {
                    THROWS89=(Token)match(input,THROWS,FOLLOW_THROWS_in_interfaceMethodDeclaration2864); if (state.failed) return ;

                    pushFollow(FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration2866);
                    qualifiedNameList();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(THROWS89); }

                    }
                    break;

            }


            SEMI90=(Token)match(input,SEMI,FOLLOW_SEMI_in_interfaceMethodDeclaration2881); if (state.failed) return ;

            if ( state.backtracking==0 ) { usb(SEMI90); addStmt((SEMI90!=null?SEMI90.getLine():0)); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 31, interfaceMethodDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "interfaceMethodDeclaration"



    // $ANTLR start "interfaceFieldDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:951:1: interfaceFieldDeclaration : modifiers type variableDeclarator ( COMMA variableDeclarator )* SEMI ;
    public final void interfaceFieldDeclaration() throws RecognitionException {
        int interfaceFieldDeclaration_StartIndex = input.index();

        Token COMMA91=null;
        Token SEMI92=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:952:5: ( modifiers type variableDeclarator ( COMMA variableDeclarator )* SEMI )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:952:9: modifiers type variableDeclarator ( COMMA variableDeclarator )* SEMI
            {
            pushFollow(FOLLOW_modifiers_in_interfaceFieldDeclaration2905);
            modifiers();

            state._fsp--;
            if (state.failed) return ;

            pushFollow(FOLLOW_type_in_interfaceFieldDeclaration2907);
            type();

            state._fsp--;
            if (state.failed) return ;

            if ( state.backtracking==0 ) { isStatic = isFinal = true; }

            pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2911);
            variableDeclarator();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:953:9: ( COMMA variableDeclarator )*
            loop63:
            do {
                int alt63=2;
                int LA63_0 = input.LA(1);

                if ( (LA63_0==COMMA) ) {
                    alt63=1;
                }


                switch (alt63) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:953:10: COMMA variableDeclarator
            	    {
            	    COMMA91=(Token)match(input,COMMA,FOLLOW_COMMA_in_interfaceFieldDeclaration2922); if (state.failed) return ;

            	    pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2924);
            	    variableDeclarator();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(COMMA91); }

            	    }
            	    break;

            	default :
            	    break loop63;
                }
            } while (true);


            SEMI92=(Token)match(input,SEMI,FOLLOW_SEMI_in_interfaceFieldDeclaration2947); if (state.failed) return ;

            if ( state.backtracking==0 ) { usb(SEMI92); addStmt((SEMI92!=null?SEMI92.getLine():0)); isStatic = isFinal = false; }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 32, interfaceFieldDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "interfaceFieldDeclaration"



    // $ANTLR start "type"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:959:1: type : ( classOrInterfaceType ( LBRACKET RBRACKET )* | primitiveType ( LBRACKET RBRACKET )* );
    public final void type() throws RecognitionException {
        int type_StartIndex = input.index();

        Token LBRACKET93=null;
        Token RBRACKET94=null;
        Token LBRACKET95=null;
        Token RBRACKET96=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:960:5: ( classOrInterfaceType ( LBRACKET RBRACKET )* | primitiveType ( LBRACKET RBRACKET )* )
            int alt66=2;
            int LA66_0 = input.LA(1);

            if ( (LA66_0==IDENTIFIER) ) {
                alt66=1;
            }
            else if ( (LA66_0==BOOLEAN||LA66_0==BYTE||LA66_0==CHAR||LA66_0==DOUBLE||LA66_0==FLOAT||LA66_0==INT||LA66_0==LONG||LA66_0==SHORT) ) {
                alt66=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 66, 0, input);

                throw nvae;

            }
            switch (alt66) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:960:9: classOrInterfaceType ( LBRACKET RBRACKET )*
                    {
                    pushFollow(FOLLOW_classOrInterfaceType_in_type2970);
                    classOrInterfaceType();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:961:9: ( LBRACKET RBRACKET )*
                    loop64:
                    do {
                        int alt64=2;
                        int LA64_0 = input.LA(1);

                        if ( (LA64_0==LBRACKET) ) {
                            alt64=1;
                        }


                        switch (alt64) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:961:10: LBRACKET RBRACKET
                    	    {
                    	    LBRACKET93=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_type2981); if (state.failed) return ;

                    	    RBRACKET94=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_type2983); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usa(LBRACKET93); usb(RBRACKET94); }

                    	    }
                    	    break;

                    	default :
                    	    break loop64;
                        }
                    } while (true);


                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:963:9: primitiveType ( LBRACKET RBRACKET )*
                    {
                    pushFollow(FOLLOW_primitiveType_in_type3006);
                    primitiveType();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:964:9: ( LBRACKET RBRACKET )*
                    loop65:
                    do {
                        int alt65=2;
                        int LA65_0 = input.LA(1);

                        if ( (LA65_0==LBRACKET) ) {
                            alt65=1;
                        }


                        switch (alt65) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:964:10: LBRACKET RBRACKET
                    	    {
                    	    LBRACKET95=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_type3017); if (state.failed) return ;

                    	    RBRACKET96=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_type3019); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usa(LBRACKET95); usb(RBRACKET96); }

                    	    }
                    	    break;

                    	default :
                    	    break loop65;
                        }
                    } while (true);


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 33, type_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "type"



    // $ANTLR start "classOrInterfaceType"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:969:1: classOrInterfaceType : IDENTIFIER ( typeArguments |a= LT b= GT )? ( DOT IDENTIFIER ( typeArguments |c= LT d= GT )? )* ;
    public final void classOrInterfaceType() throws RecognitionException {
        int classOrInterfaceType_StartIndex = input.index();

        Token a=null;
        Token b=null;
        Token c=null;
        Token d=null;
        Token DOT97=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:970:5: ( IDENTIFIER ( typeArguments |a= LT b= GT )? ( DOT IDENTIFIER ( typeArguments |c= LT d= GT )? )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:970:9: IDENTIFIER ( typeArguments |a= LT b= GT )? ( DOT IDENTIFIER ( typeArguments |c= LT d= GT )? )*
            {
            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType3053); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:971:9: ( typeArguments |a= LT b= GT )?
            int alt67=3;
            int LA67_0 = input.LA(1);

            if ( (LA67_0==LT) ) {
                int LA67_1 = input.LA(2);

                if ( (LA67_1==GT) ) {
                    alt67=2;
                }
                else if ( (LA67_1==BOOLEAN||LA67_1==BYTE||LA67_1==CHAR||LA67_1==DOUBLE||LA67_1==FLOAT||LA67_1==IDENTIFIER||LA67_1==INT||LA67_1==LONG||LA67_1==QUES||LA67_1==SHORT) ) {
                    alt67=1;
                }
            }
            switch (alt67) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:971:10: typeArguments
                    {
                    pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType3064);
                    typeArguments();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:971:26: a= LT b= GT
                    {
                    a=(Token)match(input,LT,FOLLOW_LT_in_classOrInterfaceType3070); if (state.failed) return ;

                    b=(Token)match(input,GT,FOLLOW_GT_in_classOrInterfaceType3074); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(a); usc(b); }

                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:973:9: ( DOT IDENTIFIER ( typeArguments |c= LT d= GT )? )*
            loop69:
            do {
                int alt69=2;
                int LA69_0 = input.LA(1);

                if ( (LA69_0==DOT) ) {
                    alt69=1;
                }


                switch (alt69) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:973:10: DOT IDENTIFIER ( typeArguments |c= LT d= GT )?
            	    {
            	    DOT97=(Token)match(input,DOT,FOLLOW_DOT_in_classOrInterfaceType3098); if (state.failed) return ;

            	    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType3100); if (state.failed) return ;

            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:974:13: ( typeArguments |c= LT d= GT )?
            	    int alt68=3;
            	    int LA68_0 = input.LA(1);

            	    if ( (LA68_0==LT) ) {
            	        int LA68_1 = input.LA(2);

            	        if ( (LA68_1==GT) ) {
            	            alt68=2;
            	        }
            	        else if ( (LA68_1==BOOLEAN||LA68_1==BYTE||LA68_1==CHAR||LA68_1==DOUBLE||LA68_1==FLOAT||LA68_1==IDENTIFIER||LA68_1==INT||LA68_1==LONG||LA68_1==QUES||LA68_1==SHORT) ) {
            	            alt68=1;
            	        }
            	    }
            	    switch (alt68) {
            	        case 1 :
            	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:974:14: typeArguments
            	            {
            	            pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType3115);
            	            typeArguments();

            	            state._fsp--;
            	            if (state.failed) return ;

            	            }
            	            break;
            	        case 2 :
            	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:974:30: c= LT d= GT
            	            {
            	            c=(Token)match(input,LT,FOLLOW_LT_in_classOrInterfaceType3121); if (state.failed) return ;

            	            d=(Token)match(input,GT,FOLLOW_GT_in_classOrInterfaceType3125); if (state.failed) return ;

            	            if ( state.backtracking==0 ) { usc(c); usc(d); }

            	            }
            	            break;

            	    }


            	    if ( state.backtracking==0 ) { usc(DOT97); }

            	    }
            	    break;

            	default :
            	    break loop69;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 34, classOrInterfaceType_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "classOrInterfaceType"



    // $ANTLR start "primitiveType"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:980:1: primitiveType : ( BOOLEAN | CHAR | BYTE | SHORT | INT | LONG | FLOAT | DOUBLE );
    public final void primitiveType() throws RecognitionException {
        int primitiveType_StartIndex = input.index();

        Token BOOLEAN98=null;
        Token CHAR99=null;
        Token BYTE100=null;
        Token SHORT101=null;
        Token INT102=null;
        Token LONG103=null;
        Token FLOAT104=null;
        Token DOUBLE105=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:981:5: ( BOOLEAN | CHAR | BYTE | SHORT | INT | LONG | FLOAT | DOUBLE )
            int alt70=8;
            switch ( input.LA(1) ) {
            case BOOLEAN:
                {
                alt70=1;
                }
                break;
            case CHAR:
                {
                alt70=2;
                }
                break;
            case BYTE:
                {
                alt70=3;
                }
                break;
            case SHORT:
                {
                alt70=4;
                }
                break;
            case INT:
                {
                alt70=5;
                }
                break;
            case LONG:
                {
                alt70=6;
                }
                break;
            case FLOAT:
                {
                alt70=7;
                }
                break;
            case DOUBLE:
                {
                alt70=8;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 70, 0, input);

                throw nvae;

            }

            switch (alt70) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:981:9: BOOLEAN
                    {
                    BOOLEAN98=(Token)match(input,BOOLEAN,FOLLOW_BOOLEAN_in_primitiveType3188); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(BOOLEAN98); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:982:9: CHAR
                    {
                    CHAR99=(Token)match(input,CHAR,FOLLOW_CHAR_in_primitiveType3201); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(CHAR99); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:983:9: BYTE
                    {
                    BYTE100=(Token)match(input,BYTE,FOLLOW_BYTE_in_primitiveType3214); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(BYTE100); }

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:984:9: SHORT
                    {
                    SHORT101=(Token)match(input,SHORT,FOLLOW_SHORT_in_primitiveType3227); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(SHORT101); }

                    }
                    break;
                case 5 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:985:9: INT
                    {
                    INT102=(Token)match(input,INT,FOLLOW_INT_in_primitiveType3240); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(INT102); }

                    }
                    break;
                case 6 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:986:9: LONG
                    {
                    LONG103=(Token)match(input,LONG,FOLLOW_LONG_in_primitiveType3253); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(LONG103); }

                    }
                    break;
                case 7 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:987:9: FLOAT
                    {
                    FLOAT104=(Token)match(input,FLOAT,FOLLOW_FLOAT_in_primitiveType3266); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(FLOAT104); }

                    }
                    break;
                case 8 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:988:9: DOUBLE
                    {
                    DOUBLE105=(Token)match(input,DOUBLE,FOLLOW_DOUBLE_in_primitiveType3279); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(DOUBLE105); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 35, primitiveType_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "primitiveType"



    // $ANTLR start "typeArguments"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:991:1: typeArguments : LT typeArgument ( COMMA typeArgument )* GT ;
    public final void typeArguments() throws RecognitionException {
        int typeArguments_StartIndex = input.index();

        Token COMMA106=null;
        Token LT107=null;
        Token GT108=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:992:5: ( LT typeArgument ( COMMA typeArgument )* GT )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:992:9: LT typeArgument ( COMMA typeArgument )* GT
            {
            LT107=(Token)match(input,LT,FOLLOW_LT_in_typeArguments3302); if (state.failed) return ;

            pushFollow(FOLLOW_typeArgument_in_typeArguments3304);
            typeArgument();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:993:9: ( COMMA typeArgument )*
            loop71:
            do {
                int alt71=2;
                int LA71_0 = input.LA(1);

                if ( (LA71_0==COMMA) ) {
                    alt71=1;
                }


                switch (alt71) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:993:10: COMMA typeArgument
            	    {
            	    COMMA106=(Token)match(input,COMMA,FOLLOW_COMMA_in_typeArguments3315); if (state.failed) return ;

            	    pushFollow(FOLLOW_typeArgument_in_typeArguments3317);
            	    typeArgument();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(COMMA106); }

            	    }
            	    break;

            	default :
            	    break loop71;
                }
            } while (true);


            GT108=(Token)match(input,GT,FOLLOW_GT_in_typeArguments3342); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(LT107, Key.LTYPE); usb(GT108, Key.RTYPE); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 36, typeArguments_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "typeArguments"



    // $ANTLR start "typeArgument"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:999:1: typeArgument : ( type | QUES ( ( EXTENDS | SUPER ) type )? );
    public final void typeArgument() throws RecognitionException {
        int typeArgument_StartIndex = input.index();

        Token EXTENDS109=null;
        Token SUPER110=null;
        Token QUES111=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1000:5: ( type | QUES ( ( EXTENDS | SUPER ) type )? )
            int alt74=2;
            int LA74_0 = input.LA(1);

            if ( (LA74_0==BOOLEAN||LA74_0==BYTE||LA74_0==CHAR||LA74_0==DOUBLE||LA74_0==FLOAT||LA74_0==IDENTIFIER||LA74_0==INT||LA74_0==LONG||LA74_0==SHORT) ) {
                alt74=1;
            }
            else if ( (LA74_0==QUES) ) {
                alt74=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 74, 0, input);

                throw nvae;

            }
            switch (alt74) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1000:9: type
                    {
                    pushFollow(FOLLOW_type_in_typeArgument3372);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1001:9: QUES ( ( EXTENDS | SUPER ) type )?
                    {
                    QUES111=(Token)match(input,QUES,FOLLOW_QUES_in_typeArgument3382); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1002:9: ( ( EXTENDS | SUPER ) type )?
                    int alt73=2;
                    int LA73_0 = input.LA(1);

                    if ( (LA73_0==EXTENDS||LA73_0==SUPER) ) {
                        alt73=1;
                    }
                    switch (alt73) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1003:13: ( EXTENDS | SUPER ) type
                            {
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1003:13: ( EXTENDS | SUPER )
                            int alt72=2;
                            int LA72_0 = input.LA(1);

                            if ( (LA72_0==EXTENDS) ) {
                                alt72=1;
                            }
                            else if ( (LA72_0==SUPER) ) {
                                alt72=2;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return ;}
                                NoViableAltException nvae =
                                    new NoViableAltException("", 72, 0, input);

                                throw nvae;

                            }
                            switch (alt72) {
                                case 1 :
                                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1003:14: EXTENDS
                                    {
                                    EXTENDS109=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_typeArgument3407); if (state.failed) return ;

                                    if ( state.backtracking==0 ) { usa(EXTENDS109); }

                                    }
                                    break;
                                case 2 :
                                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1004:14: SUPER
                                    {
                                    SUPER110=(Token)match(input,SUPER,FOLLOW_SUPER_in_typeArgument3424); if (state.failed) return ;

                                    if ( state.backtracking==0 ) { usa(SUPER110); }

                                    }
                                    break;

                            }


                            pushFollow(FOLLOW_type_in_typeArgument3456);
                            type();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { usc(QUES111); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 37, typeArgument_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "typeArgument"



    // $ANTLR start "qualifiedNameList"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1011:1: qualifiedNameList : qualifiedName ( COMMA qualifiedName )* ;
    public final void qualifiedNameList() throws RecognitionException {
        int qualifiedNameList_StartIndex = input.index();

        Token COMMA112=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1012:5: ( qualifiedName ( COMMA qualifiedName )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1012:9: qualifiedName ( COMMA qualifiedName )*
            {
            pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList3497);
            qualifiedName();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1013:9: ( COMMA qualifiedName )*
            loop75:
            do {
                int alt75=2;
                int LA75_0 = input.LA(1);

                if ( (LA75_0==COMMA) ) {
                    alt75=1;
                }


                switch (alt75) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1013:10: COMMA qualifiedName
            	    {
            	    COMMA112=(Token)match(input,COMMA,FOLLOW_COMMA_in_qualifiedNameList3508); if (state.failed) return ;

            	    pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList3510);
            	    qualifiedName();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(COMMA112); }

            	    }
            	    break;

            	default :
            	    break loop75;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 38, qualifiedNameList_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "qualifiedNameList"



    // $ANTLR start "formalParameters"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1017:1: formalParameters : LPAREN ( formalParameterDecls )? RPAREN ;
    public final void formalParameters() throws RecognitionException {
        int formalParameters_StartIndex = input.index();

        Token LPAREN113=null;
        Token RPAREN114=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1018:5: ( LPAREN ( formalParameterDecls )? RPAREN )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1018:9: LPAREN ( formalParameterDecls )? RPAREN
            {
            LPAREN113=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_formalParameters3543); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1019:9: ( formalParameterDecls )?
            int alt76=2;
            int LA76_0 = input.LA(1);

            if ( (LA76_0==BOOLEAN||LA76_0==BYTE||LA76_0==CHAR||LA76_0==DOUBLE||LA76_0==FINAL||LA76_0==FLOAT||LA76_0==IDENTIFIER||LA76_0==INT||LA76_0==LONG||LA76_0==MONKEYS_AT||LA76_0==SHORT) ) {
                alt76=1;
            }
            switch (alt76) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1019:10: formalParameterDecls
                    {
                    pushFollow(FOLLOW_formalParameterDecls_in_formalParameters3554);
                    formalParameterDecls();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            RPAREN114=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_formalParameters3576); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(LPAREN113); usb(LPAREN113, Key.LPAREN_METHOD); usb(RPAREN114); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 39, formalParameters_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "formalParameters"



    // $ANTLR start "formalParameterDecls"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1025:1: formalParameterDecls : ( ellipsisParameterDecl | normalParameterDecl ( COMMA normalParameterDecl )* | ( normalParameterDecl COMMA )+ ellipsisParameterDecl );
    public final void formalParameterDecls() throws RecognitionException {
        int formalParameterDecls_StartIndex = input.index();

        Token COMMA115=null;
        Token COMMA116=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1026:5: ( ellipsisParameterDecl | normalParameterDecl ( COMMA normalParameterDecl )* | ( normalParameterDecl COMMA )+ ellipsisParameterDecl )
            int alt79=3;
            switch ( input.LA(1) ) {
            case FINAL:
                {
                int LA79_1 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 1, input);

                    throw nvae;

                }
                }
                break;
            case MONKEYS_AT:
                {
                int LA79_2 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 2, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA79_3 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 3, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
                {
                int LA79_4 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 4, input);

                    throw nvae;

                }
                }
                break;
            case CHAR:
                {
                int LA79_5 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 5, input);

                    throw nvae;

                }
                }
                break;
            case BYTE:
                {
                int LA79_6 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 6, input);

                    throw nvae;

                }
                }
                break;
            case SHORT:
                {
                int LA79_7 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 7, input);

                    throw nvae;

                }
                }
                break;
            case INT:
                {
                int LA79_8 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 8, input);

                    throw nvae;

                }
                }
                break;
            case LONG:
                {
                int LA79_9 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 9, input);

                    throw nvae;

                }
                }
                break;
            case FLOAT:
                {
                int LA79_10 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 10, input);

                    throw nvae;

                }
                }
                break;
            case DOUBLE:
                {
                int LA79_11 = input.LA(2);

                if ( (synpred114_JavaTypo()) ) {
                    alt79=1;
                }
                else if ( (synpred116_JavaTypo()) ) {
                    alt79=2;
                }
                else if ( (true) ) {
                    alt79=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 79, 11, input);

                    throw nvae;

                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 79, 0, input);

                throw nvae;

            }

            switch (alt79) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1026:9: ellipsisParameterDecl
                    {
                    pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3606);
                    ellipsisParameterDecl();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1027:9: normalParameterDecl ( COMMA normalParameterDecl )*
                    {
                    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls3616);
                    normalParameterDecl();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1028:9: ( COMMA normalParameterDecl )*
                    loop77:
                    do {
                        int alt77=2;
                        int LA77_0 = input.LA(1);

                        if ( (LA77_0==COMMA) ) {
                            alt77=1;
                        }


                        switch (alt77) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1028:10: COMMA normalParameterDecl
                    	    {
                    	    COMMA115=(Token)match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls3627); if (state.failed) return ;

                    	    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls3629);
                    	    normalParameterDecl();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usc(COMMA115); }

                    	    }
                    	    break;

                    	default :
                    	    break loop77;
                        }
                    } while (true);


                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1030:9: ( normalParameterDecl COMMA )+ ellipsisParameterDecl
                    {
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1030:9: ( normalParameterDecl COMMA )+
                    int cnt78=0;
                    loop78:
                    do {
                        int alt78=2;
                        switch ( input.LA(1) ) {
                        case FINAL:
                            {
                            int LA78_1 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;
                        case MONKEYS_AT:
                            {
                            int LA78_2 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;
                        case IDENTIFIER:
                            {
                            int LA78_3 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;
                        case BOOLEAN:
                            {
                            int LA78_4 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;
                        case CHAR:
                            {
                            int LA78_5 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;
                        case BYTE:
                            {
                            int LA78_6 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;
                        case SHORT:
                            {
                            int LA78_7 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;
                        case INT:
                            {
                            int LA78_8 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;
                        case LONG:
                            {
                            int LA78_9 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;
                        case FLOAT:
                            {
                            int LA78_10 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;
                        case DOUBLE:
                            {
                            int LA78_11 = input.LA(2);

                            if ( (synpred117_JavaTypo()) ) {
                                alt78=1;
                            }


                            }
                            break;

                        }

                        switch (alt78) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1030:10: normalParameterDecl COMMA
                    	    {
                    	    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls3653);
                    	    normalParameterDecl();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    COMMA116=(Token)match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls3663); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usc(COMMA116); }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt78 >= 1 ) break loop78;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(78, input);
                                throw eee;
                        }
                        cnt78++;
                    } while (true);


                    pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3687);
                    ellipsisParameterDecl();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 40, formalParameterDecls_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "formalParameterDecls"



    // $ANTLR start "normalParameterDecl"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1036:1: normalParameterDecl : variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* ;
    public final void normalParameterDecl() throws RecognitionException {
        int normalParameterDecl_StartIndex = input.index();

        Token LBRACKET117=null;
        Token RBRACKET118=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1037:5: ( variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1037:9: variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )*
            {
            pushFollow(FOLLOW_variableModifiers_in_normalParameterDecl3707);
            variableModifiers();

            state._fsp--;
            if (state.failed) return ;

            pushFollow(FOLLOW_type_in_normalParameterDecl3709);
            type();

            state._fsp--;
            if (state.failed) return ;

            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalParameterDecl3711); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1038:9: ( LBRACKET RBRACKET )*
            loop80:
            do {
                int alt80=2;
                int LA80_0 = input.LA(1);

                if ( (LA80_0==LBRACKET) ) {
                    alt80=1;
                }


                switch (alt80) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1038:10: LBRACKET RBRACKET
            	    {
            	    LBRACKET117=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_normalParameterDecl3722); if (state.failed) return ;

            	    RBRACKET118=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_normalParameterDecl3724); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(LBRACKET117); usb(RBRACKET118); }

            	    }
            	    break;

            	default :
            	    break loop80;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 41, normalParameterDecl_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "normalParameterDecl"



    // $ANTLR start "ellipsisParameterDecl"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1042:1: ellipsisParameterDecl : variableModifiers type ELLIPSIS IDENTIFIER ;
    public final void ellipsisParameterDecl() throws RecognitionException {
        int ellipsisParameterDecl_StartIndex = input.index();

        Token ELLIPSIS119=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1043:5: ( variableModifiers type ELLIPSIS IDENTIFIER )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1043:9: variableModifiers type ELLIPSIS IDENTIFIER
            {
            pushFollow(FOLLOW_variableModifiers_in_ellipsisParameterDecl3757);
            variableModifiers();

            state._fsp--;
            if (state.failed) return ;

            pushFollow(FOLLOW_type_in_ellipsisParameterDecl3767);
            type();

            state._fsp--;
            if (state.failed) return ;

            ELLIPSIS119=(Token)match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_ellipsisParameterDecl3770); if (state.failed) return ;

            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_ellipsisParameterDecl3781); if (state.failed) return ;

            if ( state.backtracking==0 ) { usc(ELLIPSIS119); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 42, ellipsisParameterDecl_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "ellipsisParameterDecl"



    // $ANTLR start "explicitConstructorInvocation"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1050:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( THIS | SUPER ) arguments SEMI | primary DOT ( nonWildcardTypeArguments )? SUPER arguments SEMI );
    public final void explicitConstructorInvocation() throws RecognitionException {
        int explicitConstructorInvocation_StartIndex = input.index();

        Token THIS120=null;
        Token SUPER121=null;
        Token SEMI122=null;
        Token DOT123=null;
        Token SUPER124=null;
        Token SEMI125=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1051:5: ( ( nonWildcardTypeArguments )? ( THIS | SUPER ) arguments SEMI | primary DOT ( nonWildcardTypeArguments )? SUPER arguments SEMI )
            int alt84=2;
            switch ( input.LA(1) ) {
            case LT:
                {
                alt84=1;
                }
                break;
            case THIS:
                {
                int LA84_2 = input.LA(2);

                if ( (synpred121_JavaTypo()) ) {
                    alt84=1;
                }
                else if ( (true) ) {
                    alt84=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 84, 2, input);

                    throw nvae;

                }
                }
                break;
            case SUPER:
                {
                int LA84_3 = input.LA(2);

                if ( (synpred121_JavaTypo()) ) {
                    alt84=1;
                }
                else if ( (true) ) {
                    alt84=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 84, 3, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CHARLITERAL:
            case DOUBLE:
            case DOUBLELITERAL:
            case FALSE:
            case FLOAT:
            case FLOATLITERAL:
            case IDENTIFIER:
            case INT:
            case INTLITERAL:
            case LONG:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case SHORT:
            case STRINGLITERAL:
            case TRUE:
            case VOID:
                {
                alt84=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 84, 0, input);

                throw nvae;

            }

            switch (alt84) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1051:9: ( nonWildcardTypeArguments )? ( THIS | SUPER ) arguments SEMI
                    {
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1051:9: ( nonWildcardTypeArguments )?
                    int alt81=2;
                    int LA81_0 = input.LA(1);

                    if ( (LA81_0==LT) ) {
                        alt81=1;
                    }
                    switch (alt81) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1051:10: nonWildcardTypeArguments
                            {
                            pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3813);
                            nonWildcardTypeArguments();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1053:9: ( THIS | SUPER )
                    int alt82=2;
                    int LA82_0 = input.LA(1);

                    if ( (LA82_0==THIS) ) {
                        alt82=1;
                    }
                    else if ( (LA82_0==SUPER) ) {
                        alt82=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 82, 0, input);

                        throw nvae;

                    }
                    switch (alt82) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1053:10: THIS
                            {
                            THIS120=(Token)match(input,THIS,FOLLOW_THIS_in_explicitConstructorInvocation3840); if (state.failed) return ;

                            if ( state.backtracking==0 ) { usa(THIS120); }

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1054:10: SUPER
                            {
                            SUPER121=(Token)match(input,SUPER,FOLLOW_SUPER_in_explicitConstructorInvocation3854); if (state.failed) return ;

                            if ( state.backtracking==0 ) { usa(SUPER121); }

                            }
                            break;

                    }


                    pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation3877);
                    arguments();

                    state._fsp--;
                    if (state.failed) return ;

                    SEMI122=(Token)match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation3879); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(SEMI122); addStmt((SEMI122!=null?SEMI122.getLine():0)); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1059:9: primary DOT ( nonWildcardTypeArguments )? SUPER arguments SEMI
                    {
                    pushFollow(FOLLOW_primary_in_explicitConstructorInvocation3900);
                    primary();

                    state._fsp--;
                    if (state.failed) return ;

                    DOT123=(Token)match(input,DOT,FOLLOW_DOT_in_explicitConstructorInvocation3910); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1061:9: ( nonWildcardTypeArguments )?
                    int alt83=2;
                    int LA83_0 = input.LA(1);

                    if ( (LA83_0==LT) ) {
                        alt83=1;
                    }
                    switch (alt83) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1061:10: nonWildcardTypeArguments
                            {
                            pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3921);
                            nonWildcardTypeArguments();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    SUPER124=(Token)match(input,SUPER,FOLLOW_SUPER_in_explicitConstructorInvocation3942); if (state.failed) return ;

                    pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation3952);
                    arguments();

                    state._fsp--;
                    if (state.failed) return ;

                    SEMI125=(Token)match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation3954); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(DOT123); usa(SUPER124); usb(SEMI125); addStmt((SEMI125!=null?SEMI125.getLine():0)); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 43, explicitConstructorInvocation_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "explicitConstructorInvocation"



    // $ANTLR start "qualifiedName"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1068:1: qualifiedName : IDENTIFIER ( DOT IDENTIFIER )* ;
    public final void qualifiedName() throws RecognitionException {
        int qualifiedName_StartIndex = input.index();

        Token DOT126=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1069:5: ( IDENTIFIER ( DOT IDENTIFIER )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1069:9: IDENTIFIER ( DOT IDENTIFIER )*
            {
            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName3984); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1070:9: ( DOT IDENTIFIER )*
            loop85:
            do {
                int alt85=2;
                int LA85_0 = input.LA(1);

                if ( (LA85_0==DOT) ) {
                    alt85=1;
                }


                switch (alt85) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1070:10: DOT IDENTIFIER
            	    {
            	    DOT126=(Token)match(input,DOT,FOLLOW_DOT_in_qualifiedName3995); if (state.failed) return ;

            	    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName3997); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(DOT126); }

            	    }
            	    break;

            	default :
            	    break loop85;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 44, qualifiedName_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "qualifiedName"



    // $ANTLR start "annotations"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1074:1: annotations : ( annotation )+ ;
    public final void annotations() throws RecognitionException {
        int annotations_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1075:5: ( ( annotation )+ )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1075:9: ( annotation )+
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1075:9: ( annotation )+
            int cnt86=0;
            loop86:
            do {
                int alt86=2;
                int LA86_0 = input.LA(1);

                if ( (LA86_0==MONKEYS_AT) ) {
                    int LA86_2 = input.LA(2);

                    if ( (LA86_2==IDENTIFIER) ) {
                        alt86=1;
                    }


                }


                switch (alt86) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1075:10: annotation
            	    {
            	    pushFollow(FOLLOW_annotation_in_annotations4031);
            	    annotation();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    if ( cnt86 >= 1 ) break loop86;
            	    if (state.backtracking>0) {state.failed=true; return ;}
                        EarlyExitException eee =
                            new EarlyExitException(86, input);
                        throw eee;
                }
                cnt86++;
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 45, annotations_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "annotations"



    // $ANTLR start "annotation"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1083:1: annotation : MONKEYS_AT qualifiedName ( LPAREN ( elementValuePairs | elementValue )? RPAREN )? ;
    public final void annotation() throws RecognitionException {
        int annotation_StartIndex = input.index();

        Token LPAREN127=null;
        Token RPAREN128=null;
        Token MONKEYS_AT129=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1084:5: ( MONKEYS_AT qualifiedName ( LPAREN ( elementValuePairs | elementValue )? RPAREN )? )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1084:9: MONKEYS_AT qualifiedName ( LPAREN ( elementValuePairs | elementValue )? RPAREN )?
            {
            MONKEYS_AT129=(Token)match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotation4064); if (state.failed) return ;

            pushFollow(FOLLOW_qualifiedName_in_annotation4066);
            qualifiedName();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1085:9: ( LPAREN ( elementValuePairs | elementValue )? RPAREN )?
            int alt88=2;
            int LA88_0 = input.LA(1);

            if ( (LA88_0==LPAREN) ) {
                alt88=1;
            }
            switch (alt88) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1085:13: LPAREN ( elementValuePairs | elementValue )? RPAREN
                    {
                    LPAREN127=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_annotation4080); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1086:19: ( elementValuePairs | elementValue )?
                    int alt87=3;
                    int LA87_0 = input.LA(1);

                    if ( (LA87_0==IDENTIFIER) ) {
                        int LA87_1 = input.LA(2);

                        if ( (LA87_1==EQ) ) {
                            alt87=1;
                        }
                        else if ( ((LA87_1 >= AMP && LA87_1 <= AMPAMP)||(LA87_1 >= BANGEQ && LA87_1 <= BARBAR)||LA87_1==CARET||LA87_1==DOT||LA87_1==EQEQ||LA87_1==GT||LA87_1==INSTANCEOF||LA87_1==LBRACKET||(LA87_1 >= LPAREN && LA87_1 <= LT)||LA87_1==PERCENT||LA87_1==PLUS||LA87_1==PLUSPLUS||LA87_1==QUES||LA87_1==RPAREN||LA87_1==SLASH||LA87_1==STAR||LA87_1==SUB||LA87_1==SUBSUB) ) {
                            alt87=2;
                        }
                    }
                    else if ( (LA87_0==BANG||LA87_0==BOOLEAN||LA87_0==BYTE||(LA87_0 >= CHAR && LA87_0 <= CHARLITERAL)||(LA87_0 >= DOUBLE && LA87_0 <= DOUBLELITERAL)||LA87_0==FALSE||(LA87_0 >= FLOAT && LA87_0 <= FLOATLITERAL)||LA87_0==INT||LA87_0==INTLITERAL||LA87_0==LBRACE||(LA87_0 >= LONG && LA87_0 <= LPAREN)||LA87_0==MONKEYS_AT||(LA87_0 >= NEW && LA87_0 <= NULL)||LA87_0==PLUS||LA87_0==PLUSPLUS||LA87_0==SHORT||(LA87_0 >= STRINGLITERAL && LA87_0 <= SUB)||(LA87_0 >= SUBSUB && LA87_0 <= SUPER)||LA87_0==THIS||LA87_0==TILDE||LA87_0==TRUE||LA87_0==VOID) ) {
                        alt87=2;
                    }
                    switch (alt87) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1086:23: elementValuePairs
                            {
                            pushFollow(FOLLOW_elementValuePairs_in_annotation4107);
                            elementValuePairs();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1087:23: elementValue
                            {
                            pushFollow(FOLLOW_elementValue_in_annotation4131);
                            elementValue();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    RPAREN128=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_annotation4167); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(LPAREN127); usb(RPAREN128); }

                    }
                    break;

            }


            if ( state.backtracking==0 ) { usc(MONKEYS_AT129); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 46, annotation_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "annotation"



    // $ANTLR start "elementValuePairs"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1095:1: elementValuePairs : elementValuePair ( COMMA elementValuePair )* ;
    public final void elementValuePairs() throws RecognitionException {
        int elementValuePairs_StartIndex = input.index();

        Token COMMA130=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1096:5: ( elementValuePair ( COMMA elementValuePair )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1096:9: elementValuePair ( COMMA elementValuePair )*
            {
            pushFollow(FOLLOW_elementValuePair_in_elementValuePairs4223);
            elementValuePair();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1097:9: ( COMMA elementValuePair )*
            loop89:
            do {
                int alt89=2;
                int LA89_0 = input.LA(1);

                if ( (LA89_0==COMMA) ) {
                    alt89=1;
                }


                switch (alt89) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1097:10: COMMA elementValuePair
            	    {
            	    COMMA130=(Token)match(input,COMMA,FOLLOW_COMMA_in_elementValuePairs4234); if (state.failed) return ;

            	    pushFollow(FOLLOW_elementValuePair_in_elementValuePairs4236);
            	    elementValuePair();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(COMMA130); }

            	    }
            	    break;

            	default :
            	    break loop89;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 47, elementValuePairs_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "elementValuePairs"



    // $ANTLR start "elementValuePair"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1101:1: elementValuePair : IDENTIFIER EQ elementValue ;
    public final void elementValuePair() throws RecognitionException {
        int elementValuePair_StartIndex = input.index();

        Token EQ131=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1102:5: ( IDENTIFIER EQ elementValue )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1102:9: IDENTIFIER EQ elementValue
            {
            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_elementValuePair4270); if (state.failed) return ;

            EQ131=(Token)match(input,EQ,FOLLOW_EQ_in_elementValuePair4272); if (state.failed) return ;

            pushFollow(FOLLOW_elementValue_in_elementValuePair4274);
            elementValue();

            state._fsp--;
            if (state.failed) return ;

            if ( state.backtracking==0 ) { usc(EQ131); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 48, elementValuePair_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "elementValuePair"



    // $ANTLR start "elementValue"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1105:1: elementValue : ( conditionalExpression | annotation | elementValueArrayInitializer );
    public final void elementValue() throws RecognitionException {
        int elementValue_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1106:5: ( conditionalExpression | annotation | elementValueArrayInitializer )
            int alt90=3;
            switch ( input.LA(1) ) {
            case BANG:
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CHARLITERAL:
            case DOUBLE:
            case DOUBLELITERAL:
            case FALSE:
            case FLOAT:
            case FLOATLITERAL:
            case IDENTIFIER:
            case INT:
            case INTLITERAL:
            case LONG:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case PLUS:
            case PLUSPLUS:
            case SHORT:
            case STRINGLITERAL:
            case SUB:
            case SUBSUB:
            case SUPER:
            case THIS:
            case TILDE:
            case TRUE:
            case VOID:
                {
                alt90=1;
                }
                break;
            case MONKEYS_AT:
                {
                alt90=2;
                }
                break;
            case LBRACE:
                {
                alt90=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 90, 0, input);

                throw nvae;

            }

            switch (alt90) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1106:9: conditionalExpression
                    {
                    pushFollow(FOLLOW_conditionalExpression_in_elementValue4297);
                    conditionalExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1107:9: annotation
                    {
                    pushFollow(FOLLOW_annotation_in_elementValue4307);
                    annotation();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1108:9: elementValueArrayInitializer
                    {
                    pushFollow(FOLLOW_elementValueArrayInitializer_in_elementValue4317);
                    elementValueArrayInitializer();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 49, elementValue_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "elementValue"



    // $ANTLR start "elementValueArrayInitializer"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1111:1: elementValueArrayInitializer : '{' ( elementValue (a= COMMA elementValue )* )? (b= COMMA )? '}' ;
    public final void elementValueArrayInitializer() throws RecognitionException {
        int elementValueArrayInitializer_StartIndex = input.index();

        Token a=null;
        Token b=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1112:5: ( '{' ( elementValue (a= COMMA elementValue )* )? (b= COMMA )? '}' )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1112:9: '{' ( elementValue (a= COMMA elementValue )* )? (b= COMMA )? '}'
            {
            match(input,LBRACE,FOLLOW_LBRACE_in_elementValueArrayInitializer4337); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1113:9: ( elementValue (a= COMMA elementValue )* )?
            int alt92=2;
            int LA92_0 = input.LA(1);

            if ( (LA92_0==BANG||LA92_0==BOOLEAN||LA92_0==BYTE||(LA92_0 >= CHAR && LA92_0 <= CHARLITERAL)||(LA92_0 >= DOUBLE && LA92_0 <= DOUBLELITERAL)||LA92_0==FALSE||(LA92_0 >= FLOAT && LA92_0 <= FLOATLITERAL)||LA92_0==IDENTIFIER||LA92_0==INT||LA92_0==INTLITERAL||LA92_0==LBRACE||(LA92_0 >= LONG && LA92_0 <= LPAREN)||LA92_0==MONKEYS_AT||(LA92_0 >= NEW && LA92_0 <= NULL)||LA92_0==PLUS||LA92_0==PLUSPLUS||LA92_0==SHORT||(LA92_0 >= STRINGLITERAL && LA92_0 <= SUB)||(LA92_0 >= SUBSUB && LA92_0 <= SUPER)||LA92_0==THIS||LA92_0==TILDE||LA92_0==TRUE||LA92_0==VOID) ) {
                alt92=1;
            }
            switch (alt92) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1113:10: elementValue (a= COMMA elementValue )*
                    {
                    pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer4348);
                    elementValue();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1114:13: (a= COMMA elementValue )*
                    loop91:
                    do {
                        int alt91=2;
                        int LA91_0 = input.LA(1);

                        if ( (LA91_0==COMMA) ) {
                            int LA91_1 = input.LA(2);

                            if ( (LA91_1==BANG||LA91_1==BOOLEAN||LA91_1==BYTE||(LA91_1 >= CHAR && LA91_1 <= CHARLITERAL)||(LA91_1 >= DOUBLE && LA91_1 <= DOUBLELITERAL)||LA91_1==FALSE||(LA91_1 >= FLOAT && LA91_1 <= FLOATLITERAL)||LA91_1==IDENTIFIER||LA91_1==INT||LA91_1==INTLITERAL||LA91_1==LBRACE||(LA91_1 >= LONG && LA91_1 <= LPAREN)||LA91_1==MONKEYS_AT||(LA91_1 >= NEW && LA91_1 <= NULL)||LA91_1==PLUS||LA91_1==PLUSPLUS||LA91_1==SHORT||(LA91_1 >= STRINGLITERAL && LA91_1 <= SUB)||(LA91_1 >= SUBSUB && LA91_1 <= SUPER)||LA91_1==THIS||LA91_1==TILDE||LA91_1==TRUE||LA91_1==VOID) ) {
                                alt91=1;
                            }


                        }


                        switch (alt91) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1114:14: a= COMMA elementValue
                    	    {
                    	    a=(Token)match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer4365); if (state.failed) return ;

                    	    pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer4367);
                    	    elementValue();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usc(a); }

                    	    }
                    	    break;

                    	default :
                    	    break loop91;
                        }
                    } while (true);


                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1116:12: (b= COMMA )?
            int alt93=2;
            int LA93_0 = input.LA(1);

            if ( (LA93_0==COMMA) ) {
                alt93=1;
            }
            switch (alt93) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1116:13: b= COMMA
                    {
                    b=(Token)match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer4400); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(b); }

                    }
                    break;

            }


            match(input,RBRACE,FOLLOW_RBRACE_in_elementValueArrayInitializer4407); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 50, elementValueArrayInitializer_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "elementValueArrayInitializer"



    // $ANTLR start "annotationTypeDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1123:1: annotationTypeDeclaration : ( annotations )? mods MONKEYS_AT INTERFACE IDENTIFIER annotationTypeBody ;
    public final void annotationTypeDeclaration() throws RecognitionException {
        int annotationTypeDeclaration_StartIndex = input.index();

        Token MONKEYS_AT133=null;
        Token INTERFACE134=null;
        JavaTypoParser.mods_return mods132 =null;


        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 51) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1124:5: ( ( annotations )? mods MONKEYS_AT INTERFACE IDENTIFIER annotationTypeBody )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1124:9: ( annotations )? mods MONKEYS_AT INTERFACE IDENTIFIER annotationTypeBody
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1124:9: ( annotations )?
            int alt94=2;
            int LA94_0 = input.LA(1);

            if ( (LA94_0==MONKEYS_AT) ) {
                int LA94_1 = input.LA(2);

                if ( (LA94_1==IDENTIFIER) ) {
                    alt94=1;
                }
            }
            switch (alt94) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1124:9: annotations
                    {
                    pushFollow(FOLLOW_annotations_in_annotationTypeDeclaration4430);
                    annotations();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            pushFollow(FOLLOW_mods_in_annotationTypeDeclaration4433);
            mods132=mods();

            state._fsp--;
            if (state.failed) return ;

            MONKEYS_AT133=(Token)match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration4435); if (state.failed) return ;

            INTERFACE134=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationTypeDeclaration4445); if (state.failed) return ;

            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationTypeDeclaration4455); if (state.failed) return ;

            if ( state.backtracking==0 ) { ((interfaceDeclaration_scope)interfaceDeclaration_stack.peek()).first = (mods132!=null?((Token)mods132.start):null); }

            pushFollow(FOLLOW_annotationTypeBody_in_annotationTypeDeclaration4475);
            annotationTypeBody();

            state._fsp--;
            if (state.failed) return ;

            if ( state.backtracking==0 ) { usc(MONKEYS_AT133); usa(INTERFACE134); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 51, annotationTypeDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "annotationTypeDeclaration"



    // $ANTLR start "annotationTypeBody"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1133:1: annotationTypeBody : LBRACE ( annotationTypeElementDeclaration )* RBRACE ;
    public final void annotationTypeBody() throws RecognitionException {
        int annotationTypeBody_StartIndex = input.index();

        Token LBRACE135=null;
        Token RBRACE136=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 52) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1134:5: ( LBRACE ( annotationTypeElementDeclaration )* RBRACE )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1134:9: LBRACE ( annotationTypeElementDeclaration )* RBRACE
            {
            LBRACE135=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_annotationTypeBody4506); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1135:9: ( annotationTypeElementDeclaration )*
            loop95:
            do {
                int alt95=2;
                int LA95_0 = input.LA(1);

                if ( (LA95_0==ABSTRACT||LA95_0==BOOLEAN||LA95_0==BYTE||LA95_0==CHAR||LA95_0==CLASS||LA95_0==DOUBLE||LA95_0==ENUM||LA95_0==FINAL||LA95_0==FLOAT||LA95_0==IDENTIFIER||(LA95_0 >= INT && LA95_0 <= INTERFACE)||LA95_0==LONG||LA95_0==LT||(LA95_0 >= MONKEYS_AT && LA95_0 <= NATIVE)||(LA95_0 >= PRIVATE && LA95_0 <= PUBLIC)||(LA95_0 >= SEMI && LA95_0 <= SHORT)||(LA95_0 >= STATIC && LA95_0 <= STRICTFP)||LA95_0==SYNCHRONIZED||LA95_0==TRANSIENT||(LA95_0 >= VOID && LA95_0 <= VOLATILE)) ) {
                    alt95=1;
                }


                switch (alt95) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1135:10: annotationTypeElementDeclaration
            	    {
            	    pushFollow(FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody4518);
            	    annotationTypeElementDeclaration();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop95;
                }
            } while (true);


            RBRACE136=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_annotationTypeBody4540); if (state.failed) return ;

            if ( state.backtracking==0 ) { updateBrace(((interfaceDeclaration_scope)interfaceDeclaration_stack.peek()).first, LBRACE135, RBRACE136); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 52, annotationTypeBody_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "annotationTypeBody"



    // $ANTLR start "annotationTypeElementDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1144:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | SEMI );
    public final void annotationTypeElementDeclaration() throws RecognitionException {
        int annotationTypeElementDeclaration_StartIndex = input.index();

        Token SEMI137=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 53) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1145:5: ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | SEMI )
            int alt96=7;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA96_1 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA96_2 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA96_3 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA96_4 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA96_5 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA96_6 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA96_7 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA96_8 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA96_9 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA96_10 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA96_11 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA96_12 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else if ( (synpred138_JavaTypo()) ) {
                    alt96=3;
                }
                else if ( (synpred139_JavaTypo()) ) {
                    alt96=4;
                }
                else if ( (synpred140_JavaTypo()) ) {
                    alt96=5;
                }
                else if ( (synpred141_JavaTypo()) ) {
                    alt96=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 12, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA96_13 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 13, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
                {
                int LA96_14 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 14, input);

                    throw nvae;

                }
                }
                break;
            case CHAR:
                {
                int LA96_15 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 15, input);

                    throw nvae;

                }
                }
                break;
            case BYTE:
                {
                int LA96_16 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 16, input);

                    throw nvae;

                }
                }
                break;
            case SHORT:
                {
                int LA96_17 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 17, input);

                    throw nvae;

                }
                }
                break;
            case INT:
                {
                int LA96_18 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 18, input);

                    throw nvae;

                }
                }
                break;
            case LONG:
                {
                int LA96_19 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 19, input);

                    throw nvae;

                }
                }
                break;
            case FLOAT:
                {
                int LA96_20 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 20, input);

                    throw nvae;

                }
                }
                break;
            case DOUBLE:
                {
                int LA96_21 = input.LA(2);

                if ( (synpred136_JavaTypo()) ) {
                    alt96=1;
                }
                else if ( (synpred137_JavaTypo()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 21, input);

                    throw nvae;

                }
                }
                break;
            case CLASS:
                {
                alt96=3;
                }
                break;
            case INTERFACE:
                {
                alt96=4;
                }
                break;
            case ENUM:
                {
                alt96=5;
                }
                break;
            case SEMI:
                {
                alt96=7;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 96, 0, input);

                throw nvae;

            }

            switch (alt96) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1145:9: annotationMethodDeclaration
                    {
                    pushFollow(FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration4572);
                    annotationMethodDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1146:9: interfaceFieldDeclaration
                    {
                    pushFollow(FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration4582);
                    interfaceFieldDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1147:9: normalClassDeclaration
                    {
                    pushFollow(FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration4592);
                    normalClassDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1148:9: normalInterfaceDeclaration
                    {
                    pushFollow(FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration4602);
                    normalInterfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1149:9: enumDeclaration
                    {
                    pushFollow(FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration4612);
                    enumDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 6 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1150:9: annotationTypeDeclaration
                    {
                    pushFollow(FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration4622);
                    annotationTypeDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 7 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1151:9: SEMI
                    {
                    SEMI137=(Token)match(input,SEMI,FOLLOW_SEMI_in_annotationTypeElementDeclaration4632); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(SEMI137); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 53, annotationTypeElementDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "annotationTypeElementDeclaration"



    // $ANTLR start "annotationMethodDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1154:1: annotationMethodDeclaration : modifiers type IDENTIFIER LPAREN RPAREN ( DEFAULT elementValue )? SEMI ;
    public final void annotationMethodDeclaration() throws RecognitionException {
        int annotationMethodDeclaration_StartIndex = input.index();

        Token DEFAULT138=null;
        Token LPAREN139=null;
        Token RPAREN140=null;
        Token SEMI141=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 54) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1155:5: ( modifiers type IDENTIFIER LPAREN RPAREN ( DEFAULT elementValue )? SEMI )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1155:9: modifiers type IDENTIFIER LPAREN RPAREN ( DEFAULT elementValue )? SEMI
            {
            pushFollow(FOLLOW_modifiers_in_annotationMethodDeclaration4654);
            modifiers();

            state._fsp--;
            if (state.failed) return ;

            pushFollow(FOLLOW_type_in_annotationMethodDeclaration4656);
            type();

            state._fsp--;
            if (state.failed) return ;

            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationMethodDeclaration4658); if (state.failed) return ;

            LPAREN139=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_annotationMethodDeclaration4668); if (state.failed) return ;

            RPAREN140=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_annotationMethodDeclaration4670); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1156:23: ( DEFAULT elementValue )?
            int alt97=2;
            int LA97_0 = input.LA(1);

            if ( (LA97_0==DEFAULT) ) {
                alt97=1;
            }
            switch (alt97) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1156:24: DEFAULT elementValue
                    {
                    DEFAULT138=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_annotationMethodDeclaration4673); if (state.failed) return ;

                    pushFollow(FOLLOW_elementValue_in_annotationMethodDeclaration4675);
                    elementValue();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(DEFAULT138, Key.DEFAULT_ANNOTATION); }

                    }
                    break;

            }


            SEMI141=(Token)match(input,SEMI,FOLLOW_SEMI_in_annotationMethodDeclaration4706); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(LPAREN139); usb(RPAREN140); usb(SEMI141); addStmt((SEMI141!=null?SEMI141.getLine():0)); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 54, annotationMethodDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "annotationMethodDeclaration"


    public static class block_return extends ParserRuleReturnScope {
    };


    // $ANTLR start "block"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1162:1: block : LBRACE ( blockStatement )* RBRACE ;
    public final JavaTypoParser.block_return block() throws RecognitionException {
        JavaTypoParser.block_return retval = new JavaTypoParser.block_return();
        retval.start = input.LT(1);

        int block_StartIndex = input.index();

        Token LBRACE142=null;
        Token RBRACE143=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return retval; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1163:5: ( LBRACE ( blockStatement )* RBRACE )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1163:9: LBRACE ( blockStatement )* RBRACE
            {
            LBRACE142=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_block4740); if (state.failed) return retval;

            if ( state.backtracking==0 ) { encountered.push(LBRACE142); }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1165:9: ( blockStatement )*
            loop98:
            do {
                int alt98=2;
                int LA98_0 = input.LA(1);

                if ( (LA98_0==ABSTRACT||(LA98_0 >= ASSERT && LA98_0 <= BANG)||(LA98_0 >= BOOLEAN && LA98_0 <= BYTE)||(LA98_0 >= CHAR && LA98_0 <= CLASS)||LA98_0==CONTINUE||LA98_0==DO||(LA98_0 >= DOUBLE && LA98_0 <= DOUBLELITERAL)||LA98_0==ENUM||(LA98_0 >= FALSE && LA98_0 <= FINAL)||(LA98_0 >= FLOAT && LA98_0 <= FOR)||(LA98_0 >= IDENTIFIER && LA98_0 <= IF)||(LA98_0 >= INT && LA98_0 <= INTLITERAL)||LA98_0==LBRACE||(LA98_0 >= LONG && LA98_0 <= LT)||(LA98_0 >= MONKEYS_AT && LA98_0 <= NULL)||LA98_0==PLUS||(LA98_0 >= PLUSPLUS && LA98_0 <= PUBLIC)||LA98_0==RETURN||(LA98_0 >= SEMI && LA98_0 <= SHORT)||(LA98_0 >= STATIC && LA98_0 <= SUB)||(LA98_0 >= SUBSUB && LA98_0 <= SYNCHRONIZED)||(LA98_0 >= THIS && LA98_0 <= THROW)||(LA98_0 >= TILDE && LA98_0 <= WHILE)) ) {
                    alt98=1;
                }


                switch (alt98) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1165:10: blockStatement
            	    {
            	    pushFollow(FOLLOW_blockStatement_in_block4758);
            	    blockStatement();

            	    state._fsp--;
            	    if (state.failed) return retval;

            	    }
            	    break;

            	default :
            	    break loop98;
                }
            } while (true);


            RBRACE143=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_block4779); if (state.failed) return retval;

            if ( state.backtracking==0 ) { 
                    	Token prev = encountered.pop(); 
                    	
                    	if (encountered.size() > 0)
                    	{
            	        	Token prevPrev = encountered.pop();
            	        	
            	        	if ("{".equals(prevPrev.getText()))
            	        		encountered.push(prevPrev);
            	        	
            	        	else
            	        		updateBrace(prevPrev, prev, RBRACE143);
            		}
                    }

            }

            retval.stop = input.LT(-1);


        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 55, block_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "block"



    // $ANTLR start "blockStatement"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1208:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement );
    public final void blockStatement() throws RecognitionException {
        int blockStatement_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 56) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1209:5: ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement )
            int alt99=3;
            switch ( input.LA(1) ) {
            case FINAL:
                {
                int LA99_1 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (synpred145_JavaTypo()) ) {
                    alt99=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 1, input);

                    throw nvae;

                }
                }
                break;
            case MONKEYS_AT:
                {
                int LA99_2 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (synpred145_JavaTypo()) ) {
                    alt99=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 2, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA99_3 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (true) ) {
                    alt99=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 3, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
                {
                int LA99_4 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (true) ) {
                    alt99=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 4, input);

                    throw nvae;

                }
                }
                break;
            case CHAR:
                {
                int LA99_5 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (true) ) {
                    alt99=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 5, input);

                    throw nvae;

                }
                }
                break;
            case BYTE:
                {
                int LA99_6 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (true) ) {
                    alt99=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 6, input);

                    throw nvae;

                }
                }
                break;
            case SHORT:
                {
                int LA99_7 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (true) ) {
                    alt99=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 7, input);

                    throw nvae;

                }
                }
                break;
            case INT:
                {
                int LA99_8 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (true) ) {
                    alt99=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 8, input);

                    throw nvae;

                }
                }
                break;
            case LONG:
                {
                int LA99_9 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (true) ) {
                    alt99=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 9, input);

                    throw nvae;

                }
                }
                break;
            case FLOAT:
                {
                int LA99_10 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (true) ) {
                    alt99=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 10, input);

                    throw nvae;

                }
                }
                break;
            case DOUBLE:
                {
                int LA99_11 = input.LA(2);

                if ( (synpred144_JavaTypo()) ) {
                    alt99=1;
                }
                else if ( (true) ) {
                    alt99=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 11, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
            case CLASS:
            case ENUM:
            case INTERFACE:
            case NATIVE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case STATIC:
            case STRICTFP:
            case TRANSIENT:
            case VOLATILE:
                {
                alt99=2;
                }
                break;
            case SYNCHRONIZED:
                {
                int LA99_18 = input.LA(2);

                if ( (synpred145_JavaTypo()) ) {
                    alt99=2;
                }
                else if ( (true) ) {
                    alt99=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 99, 18, input);

                    throw nvae;

                }
                }
                break;
            case ASSERT:
            case BANG:
            case BREAK:
            case CHARLITERAL:
            case CONTINUE:
            case DO:
            case DOUBLELITERAL:
            case FALSE:
            case FLOATLITERAL:
            case FOR:
            case IF:
            case INTLITERAL:
            case LBRACE:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case PLUS:
            case PLUSPLUS:
            case RETURN:
            case SEMI:
            case STRINGLITERAL:
            case SUB:
            case SUBSUB:
            case SUPER:
            case SWITCH:
            case THIS:
            case THROW:
            case TILDE:
            case TRUE:
            case TRY:
            case VOID:
            case WHILE:
                {
                alt99=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 99, 0, input);

                throw nvae;

            }

            switch (alt99) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1209:9: localVariableDeclarationStatement
                    {
                    pushFollow(FOLLOW_localVariableDeclarationStatement_in_blockStatement4811);
                    localVariableDeclarationStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1210:9: classOrInterfaceDeclaration
                    {
                    pushFollow(FOLLOW_classOrInterfaceDeclaration_in_blockStatement4821);
                    classOrInterfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1211:9: statement
                    {
                    pushFollow(FOLLOW_statement_in_blockStatement4831);
                    statement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 56, blockStatement_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "blockStatement"



    // $ANTLR start "localVariableDeclarationStatement"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1215:1: localVariableDeclarationStatement : localVariableDeclaration SEMI ;
    public final void localVariableDeclarationStatement() throws RecognitionException {
        int localVariableDeclarationStatement_StartIndex = input.index();

        Token SEMI144=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 57) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1216:5: ( localVariableDeclaration SEMI )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1216:9: localVariableDeclaration SEMI
            {
            pushFollow(FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement4852);
            localVariableDeclaration();

            state._fsp--;
            if (state.failed) return ;

            SEMI144=(Token)match(input,SEMI,FOLLOW_SEMI_in_localVariableDeclarationStatement4862); if (state.failed) return ;

            if ( state.backtracking==0 ) { usb(SEMI144); addStmt((SEMI144!=null?SEMI144.getLine():0)); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 57, localVariableDeclarationStatement_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "localVariableDeclarationStatement"



    // $ANTLR start "localVariableDeclaration"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1221:1: localVariableDeclaration : variableModifiers type variableDeclarator ( COMMA variableDeclarator )* ;
    public final void localVariableDeclaration() throws RecognitionException {
        int localVariableDeclaration_StartIndex = input.index();

        Token COMMA145=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 58) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1222:5: ( variableModifiers type variableDeclarator ( COMMA variableDeclarator )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1222:9: variableModifiers type variableDeclarator ( COMMA variableDeclarator )*
            {
            pushFollow(FOLLOW_variableModifiers_in_localVariableDeclaration4892);
            variableModifiers();

            state._fsp--;
            if (state.failed) return ;

            pushFollow(FOLLOW_type_in_localVariableDeclaration4894);
            type();

            state._fsp--;
            if (state.failed) return ;

            pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration4904);
            variableDeclarator();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1224:9: ( COMMA variableDeclarator )*
            loop100:
            do {
                int alt100=2;
                int LA100_0 = input.LA(1);

                if ( (LA100_0==COMMA) ) {
                    alt100=1;
                }


                switch (alt100) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1224:10: COMMA variableDeclarator
            	    {
            	    COMMA145=(Token)match(input,COMMA,FOLLOW_COMMA_in_localVariableDeclaration4915); if (state.failed) return ;

            	    pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration4917);
            	    variableDeclarator();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(COMMA145); }

            	    }
            	    break;

            	default :
            	    break loop100;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 58, localVariableDeclaration_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "localVariableDeclaration"



    // $ANTLR start "statement"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1228:1: statement : ( block | ( ASSERT ) expression ( COLON expression )? SEMI | ASSERT expression ( COLON expression )? SEMI |a= IF parExpression ( block | statement ) (c= ELSE b= IF parExpression ( block | statement ) )* (d= ELSE ( block | statement ) )? | forstatement | WHILE parExpression ( block | statement ) | DO ( block | statement ) WHILE parExpression SEMI | trystatement | SWITCH parExpression LBRACE switchBlockStatementGroups RBRACE | SYNCHRONIZED parExpression block | RETURN ( expression )? SEMI | THROW expression SEMI | BREAK ( IDENTIFIER )? SEMI | CONTINUE ( IDENTIFIER )? SEMI | expression SEMI | IDENTIFIER COLON statement | SEMI );
    public final void statement() throws RecognitionException {
        int statement_StartIndex = input.index();

        Token a=null;
        Token c=null;
        Token b=null;
        Token d=null;
        Token COLON146=null;
        Token ASSERT147=null;
        Token SEMI148=null;
        Token COLON149=null;
        Token ASSERT150=null;
        Token SEMI151=null;
        Token WHILE152=null;
        Token DO153=null;
        Token WHILE154=null;
        Token SEMI155=null;
        Token SWITCH156=null;
        Token LBRACE157=null;
        Token RBRACE158=null;
        Token SYNCHRONIZED159=null;
        Token RETURN161=null;
        Token SEMI162=null;
        Token THROW163=null;
        Token SEMI164=null;
        Token BREAK165=null;
        Token SEMI166=null;
        Token CONTINUE167=null;
        Token SEMI168=null;
        Token SEMI169=null;
        Token COLON170=null;
        Token SEMI171=null;
        JavaTypoParser.block_return block160 =null;


        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 59) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1229:5: ( block | ( ASSERT ) expression ( COLON expression )? SEMI | ASSERT expression ( COLON expression )? SEMI |a= IF parExpression ( block | statement ) (c= ELSE b= IF parExpression ( block | statement ) )* (d= ELSE ( block | statement ) )? | forstatement | WHILE parExpression ( block | statement ) | DO ( block | statement ) WHILE parExpression SEMI | trystatement | SWITCH parExpression LBRACE switchBlockStatementGroups RBRACE | SYNCHRONIZED parExpression block | RETURN ( expression )? SEMI | THROW expression SEMI | BREAK ( IDENTIFIER )? SEMI | CONTINUE ( IDENTIFIER )? SEMI | expression SEMI | IDENTIFIER COLON statement | SEMI )
            int alt113=17;
            switch ( input.LA(1) ) {
            case LBRACE:
                {
                alt113=1;
                }
                break;
            case ASSERT:
                {
                int LA113_2 = input.LA(2);

                if ( (synpred149_JavaTypo()) ) {
                    alt113=2;
                }
                else if ( (synpred151_JavaTypo()) ) {
                    alt113=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 113, 2, input);

                    throw nvae;

                }
                }
                break;
            case IF:
                {
                alt113=4;
                }
                break;
            case FOR:
                {
                alt113=5;
                }
                break;
            case WHILE:
                {
                alt113=6;
                }
                break;
            case DO:
                {
                alt113=7;
                }
                break;
            case TRY:
                {
                alt113=8;
                }
                break;
            case SWITCH:
                {
                alt113=9;
                }
                break;
            case SYNCHRONIZED:
                {
                alt113=10;
                }
                break;
            case RETURN:
                {
                alt113=11;
                }
                break;
            case THROW:
                {
                alt113=12;
                }
                break;
            case BREAK:
                {
                alt113=13;
                }
                break;
            case CONTINUE:
                {
                alt113=14;
                }
                break;
            case BANG:
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CHARLITERAL:
            case DOUBLE:
            case DOUBLELITERAL:
            case FALSE:
            case FLOAT:
            case FLOATLITERAL:
            case INT:
            case INTLITERAL:
            case LONG:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case PLUS:
            case PLUSPLUS:
            case SHORT:
            case STRINGLITERAL:
            case SUB:
            case SUBSUB:
            case SUPER:
            case THIS:
            case TILDE:
            case TRUE:
            case VOID:
                {
                alt113=15;
                }
                break;
            case IDENTIFIER:
                {
                int LA113_22 = input.LA(2);

                if ( (synpred173_JavaTypo()) ) {
                    alt113=15;
                }
                else if ( (synpred174_JavaTypo()) ) {
                    alt113=16;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 113, 22, input);

                    throw nvae;

                }
                }
                break;
            case SEMI:
                {
                alt113=17;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 113, 0, input);

                throw nvae;

            }

            switch (alt113) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1229:9: block
                    {
                    pushFollow(FOLLOW_block_in_statement4950);
                    block();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1230:9: ( ASSERT ) expression ( COLON expression )? SEMI
                    {
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1230:9: ( ASSERT )
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1230:10: ASSERT
                    {
                    ASSERT147=(Token)match(input,ASSERT,FOLLOW_ASSERT_in_statement4974); if (state.failed) return ;

                    }


                    pushFollow(FOLLOW_expression_in_statement4994);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1232:20: ( COLON expression )?
                    int alt101=2;
                    int LA101_0 = input.LA(1);

                    if ( (LA101_0==COLON) ) {
                        alt101=1;
                    }
                    switch (alt101) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1232:21: COLON expression
                            {
                            COLON146=(Token)match(input,COLON,FOLLOW_COLON_in_statement4997); if (state.failed) return ;

                            pushFollow(FOLLOW_expression_in_statement4999);
                            expression();

                            state._fsp--;
                            if (state.failed) return ;

                            if ( state.backtracking==0 ) { usc(COLON146, Key.COLON_OPERATOR); }

                            }
                            break;

                    }


                    SEMI148=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5005); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(ASSERT147); usb(SEMI148); addStmt((SEMI148!=null?SEMI148.getLine():0)); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1234:9: ASSERT expression ( COLON expression )? SEMI
                    {
                    ASSERT150=(Token)match(input,ASSERT,FOLLOW_ASSERT_in_statement5033); if (state.failed) return ;

                    pushFollow(FOLLOW_expression_in_statement5036);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1234:28: ( COLON expression )?
                    int alt102=2;
                    int LA102_0 = input.LA(1);

                    if ( (LA102_0==COLON) ) {
                        alt102=1;
                    }
                    switch (alt102) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1234:29: COLON expression
                            {
                            COLON149=(Token)match(input,COLON,FOLLOW_COLON_in_statement5039); if (state.failed) return ;

                            pushFollow(FOLLOW_expression_in_statement5041);
                            expression();

                            state._fsp--;
                            if (state.failed) return ;

                            if ( state.backtracking==0 ) { usc(COLON149, Key.COLON_OPERATOR); }

                            }
                            break;

                    }


                    SEMI151=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5047); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(ASSERT150); usb(SEMI151); addStmt((SEMI151!=null?SEMI151.getLine():0)); }

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1235:9: a= IF parExpression ( block | statement ) (c= ELSE b= IF parExpression ( block | statement ) )* (d= ELSE ( block | statement ) )?
                    {
                    a=(Token)match(input,IF,FOLLOW_IF_in_statement5065); if (state.failed) return ;

                    pushFollow(FOLLOW_parExpression_in_statement5074);
                    parExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1236:20: ( block | statement )
                    int alt103=2;
                    int LA103_0 = input.LA(1);

                    if ( (LA103_0==LBRACE) ) {
                        int LA103_1 = input.LA(2);

                        if ( (synpred152_JavaTypo()) ) {
                            alt103=1;
                        }
                        else if ( (true) ) {
                            alt103=2;
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return ;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 103, 1, input);

                            throw nvae;

                        }
                    }
                    else if ( ((LA103_0 >= ASSERT && LA103_0 <= BANG)||(LA103_0 >= BOOLEAN && LA103_0 <= BYTE)||(LA103_0 >= CHAR && LA103_0 <= CHARLITERAL)||LA103_0==CONTINUE||LA103_0==DO||(LA103_0 >= DOUBLE && LA103_0 <= DOUBLELITERAL)||LA103_0==FALSE||(LA103_0 >= FLOAT && LA103_0 <= FOR)||(LA103_0 >= IDENTIFIER && LA103_0 <= IF)||LA103_0==INT||LA103_0==INTLITERAL||(LA103_0 >= LONG && LA103_0 <= LPAREN)||(LA103_0 >= NEW && LA103_0 <= NULL)||LA103_0==PLUS||LA103_0==PLUSPLUS||LA103_0==RETURN||(LA103_0 >= SEMI && LA103_0 <= SHORT)||(LA103_0 >= STRINGLITERAL && LA103_0 <= SUB)||(LA103_0 >= SUBSUB && LA103_0 <= SYNCHRONIZED)||(LA103_0 >= THIS && LA103_0 <= THROW)||LA103_0==TILDE||(LA103_0 >= TRUE && LA103_0 <= VOID)||LA103_0==WHILE) ) {
                        alt103=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 103, 0, input);

                        throw nvae;

                    }
                    switch (alt103) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1236:21: block
                            {
                            if ( state.backtracking==0 ) { encountered.push(a); }

                            pushFollow(FOLLOW_block_in_statement5079);
                            block();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1236:54: statement
                            {
                            pushFollow(FOLLOW_statement_in_statement5083);
                            statement();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:6: (c= ELSE b= IF parExpression ( block | statement ) )*
                    loop105:
                    do {
                        int alt105=2;
                        int LA105_0 = input.LA(1);

                        if ( (LA105_0==ELSE) ) {
                            int LA105_1 = input.LA(2);

                            if ( (synpred154_JavaTypo()) ) {
                                alt105=1;
                            }


                        }


                        switch (alt105) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:7: c= ELSE b= IF parExpression ( block | statement )
                    	    {
                    	    c=(Token)match(input,ELSE,FOLLOW_ELSE_in_statement5095); if (state.failed) return ;

                    	    b=(Token)match(input,IF,FOLLOW_IF_in_statement5099); if (state.failed) return ;

                    	    pushFollow(FOLLOW_parExpression_in_statement5101);
                    	    parExpression();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:33: ( block | statement )
                    	    int alt104=2;
                    	    int LA104_0 = input.LA(1);

                    	    if ( (LA104_0==LBRACE) ) {
                    	        int LA104_1 = input.LA(2);

                    	        if ( (synpred153_JavaTypo()) ) {
                    	            alt104=1;
                    	        }
                    	        else if ( (true) ) {
                    	            alt104=2;
                    	        }
                    	        else {
                    	            if (state.backtracking>0) {state.failed=true; return ;}
                    	            NoViableAltException nvae =
                    	                new NoViableAltException("", 104, 1, input);

                    	            throw nvae;

                    	        }
                    	    }
                    	    else if ( ((LA104_0 >= ASSERT && LA104_0 <= BANG)||(LA104_0 >= BOOLEAN && LA104_0 <= BYTE)||(LA104_0 >= CHAR && LA104_0 <= CHARLITERAL)||LA104_0==CONTINUE||LA104_0==DO||(LA104_0 >= DOUBLE && LA104_0 <= DOUBLELITERAL)||LA104_0==FALSE||(LA104_0 >= FLOAT && LA104_0 <= FOR)||(LA104_0 >= IDENTIFIER && LA104_0 <= IF)||LA104_0==INT||LA104_0==INTLITERAL||(LA104_0 >= LONG && LA104_0 <= LPAREN)||(LA104_0 >= NEW && LA104_0 <= NULL)||LA104_0==PLUS||LA104_0==PLUSPLUS||LA104_0==RETURN||(LA104_0 >= SEMI && LA104_0 <= SHORT)||(LA104_0 >= STRINGLITERAL && LA104_0 <= SUB)||(LA104_0 >= SUBSUB && LA104_0 <= SYNCHRONIZED)||(LA104_0 >= THIS && LA104_0 <= THROW)||LA104_0==TILDE||(LA104_0 >= TRUE && LA104_0 <= VOID)||LA104_0==WHILE) ) {
                    	        alt104=2;
                    	    }
                    	    else {
                    	        if (state.backtracking>0) {state.failed=true; return ;}
                    	        NoViableAltException nvae =
                    	            new NoViableAltException("", 104, 0, input);

                    	        throw nvae;

                    	    }
                    	    switch (alt104) {
                    	        case 1 :
                    	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:34: block
                    	            {
                    	            if ( state.backtracking==0 ) { encountered.push(c); }

                    	            pushFollow(FOLLOW_block_in_statement5106);
                    	            block();

                    	            state._fsp--;
                    	            if (state.failed) return ;

                    	            }
                    	            break;
                    	        case 2 :
                    	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:67: statement
                    	            {
                    	            pushFollow(FOLLOW_statement_in_statement5110);
                    	            statement();

                    	            state._fsp--;
                    	            if (state.failed) return ;

                    	            }
                    	            break;

                    	    }


                    	    if ( state.backtracking==0 ) { usa(c); usa(b); }

                    	    }
                    	    break;

                    	default :
                    	    break loop105;
                        }
                    } while (true);


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:6: (d= ELSE ( block | statement ) )?
                    int alt107=2;
                    int LA107_0 = input.LA(1);

                    if ( (LA107_0==ELSE) ) {
                        int LA107_1 = input.LA(2);

                        if ( (synpred156_JavaTypo()) ) {
                            alt107=1;
                        }
                    }
                    switch (alt107) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:7: d= ELSE ( block | statement )
                            {
                            d=(Token)match(input,ELSE,FOLLOW_ELSE_in_statement5131); if (state.failed) return ;

                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:14: ( block | statement )
                            int alt106=2;
                            int LA106_0 = input.LA(1);

                            if ( (LA106_0==LBRACE) ) {
                                int LA106_1 = input.LA(2);

                                if ( (synpred155_JavaTypo()) ) {
                                    alt106=1;
                                }
                                else if ( (true) ) {
                                    alt106=2;
                                }
                                else {
                                    if (state.backtracking>0) {state.failed=true; return ;}
                                    NoViableAltException nvae =
                                        new NoViableAltException("", 106, 1, input);

                                    throw nvae;

                                }
                            }
                            else if ( ((LA106_0 >= ASSERT && LA106_0 <= BANG)||(LA106_0 >= BOOLEAN && LA106_0 <= BYTE)||(LA106_0 >= CHAR && LA106_0 <= CHARLITERAL)||LA106_0==CONTINUE||LA106_0==DO||(LA106_0 >= DOUBLE && LA106_0 <= DOUBLELITERAL)||LA106_0==FALSE||(LA106_0 >= FLOAT && LA106_0 <= FOR)||(LA106_0 >= IDENTIFIER && LA106_0 <= IF)||LA106_0==INT||LA106_0==INTLITERAL||(LA106_0 >= LONG && LA106_0 <= LPAREN)||(LA106_0 >= NEW && LA106_0 <= NULL)||LA106_0==PLUS||LA106_0==PLUSPLUS||LA106_0==RETURN||(LA106_0 >= SEMI && LA106_0 <= SHORT)||(LA106_0 >= STRINGLITERAL && LA106_0 <= SUB)||(LA106_0 >= SUBSUB && LA106_0 <= SYNCHRONIZED)||(LA106_0 >= THIS && LA106_0 <= THROW)||LA106_0==TILDE||(LA106_0 >= TRUE && LA106_0 <= VOID)||LA106_0==WHILE) ) {
                                alt106=2;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return ;}
                                NoViableAltException nvae =
                                    new NoViableAltException("", 106, 0, input);

                                throw nvae;

                            }
                            switch (alt106) {
                                case 1 :
                                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:15: block
                                    {
                                    if ( state.backtracking==0 ) { encountered.push(d); }

                                    pushFollow(FOLLOW_block_in_statement5136);
                                    block();

                                    state._fsp--;
                                    if (state.failed) return ;

                                    }
                                    break;
                                case 2 :
                                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:48: statement
                                    {
                                    pushFollow(FOLLOW_statement_in_statement5140);
                                    statement();

                                    state._fsp--;
                                    if (state.failed) return ;

                                    }
                                    break;

                            }


                            if ( state.backtracking==0 ) { usa(d); }

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { usa(a); }

                    }
                    break;
                case 5 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1240:9: forstatement
                    {
                    pushFollow(FOLLOW_forstatement_in_statement5164);
                    forstatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 6 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1241:9: WHILE parExpression ( block | statement )
                    {
                    WHILE152=(Token)match(input,WHILE,FOLLOW_WHILE_in_statement5174); if (state.failed) return ;

                    pushFollow(FOLLOW_parExpression_in_statement5176);
                    parExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1241:29: ( block | statement )
                    int alt108=2;
                    int LA108_0 = input.LA(1);

                    if ( (LA108_0==LBRACE) ) {
                        int LA108_1 = input.LA(2);

                        if ( (synpred159_JavaTypo()) ) {
                            alt108=1;
                        }
                        else if ( (true) ) {
                            alt108=2;
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return ;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 108, 1, input);

                            throw nvae;

                        }
                    }
                    else if ( ((LA108_0 >= ASSERT && LA108_0 <= BANG)||(LA108_0 >= BOOLEAN && LA108_0 <= BYTE)||(LA108_0 >= CHAR && LA108_0 <= CHARLITERAL)||LA108_0==CONTINUE||LA108_0==DO||(LA108_0 >= DOUBLE && LA108_0 <= DOUBLELITERAL)||LA108_0==FALSE||(LA108_0 >= FLOAT && LA108_0 <= FOR)||(LA108_0 >= IDENTIFIER && LA108_0 <= IF)||LA108_0==INT||LA108_0==INTLITERAL||(LA108_0 >= LONG && LA108_0 <= LPAREN)||(LA108_0 >= NEW && LA108_0 <= NULL)||LA108_0==PLUS||LA108_0==PLUSPLUS||LA108_0==RETURN||(LA108_0 >= SEMI && LA108_0 <= SHORT)||(LA108_0 >= STRINGLITERAL && LA108_0 <= SUB)||(LA108_0 >= SUBSUB && LA108_0 <= SYNCHRONIZED)||(LA108_0 >= THIS && LA108_0 <= THROW)||LA108_0==TILDE||(LA108_0 >= TRUE && LA108_0 <= VOID)||LA108_0==WHILE) ) {
                        alt108=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 108, 0, input);

                        throw nvae;

                    }
                    switch (alt108) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1241:30: block
                            {
                            if ( state.backtracking==0 ) { encountered.push(WHILE152); }

                            pushFollow(FOLLOW_block_in_statement5181);
                            block();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1241:68: statement
                            {
                            pushFollow(FOLLOW_statement_in_statement5185);
                            statement();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { usa(WHILE152); }

                    }
                    break;
                case 7 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1242:9: DO ( block | statement ) WHILE parExpression SEMI
                    {
                    DO153=(Token)match(input,DO,FOLLOW_DO_in_statement5198); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1242:12: ( block | statement )
                    int alt109=2;
                    int LA109_0 = input.LA(1);

                    if ( (LA109_0==LBRACE) ) {
                        int LA109_1 = input.LA(2);

                        if ( (synpred161_JavaTypo()) ) {
                            alt109=1;
                        }
                        else if ( (true) ) {
                            alt109=2;
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return ;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 109, 1, input);

                            throw nvae;

                        }
                    }
                    else if ( ((LA109_0 >= ASSERT && LA109_0 <= BANG)||(LA109_0 >= BOOLEAN && LA109_0 <= BYTE)||(LA109_0 >= CHAR && LA109_0 <= CHARLITERAL)||LA109_0==CONTINUE||LA109_0==DO||(LA109_0 >= DOUBLE && LA109_0 <= DOUBLELITERAL)||LA109_0==FALSE||(LA109_0 >= FLOAT && LA109_0 <= FOR)||(LA109_0 >= IDENTIFIER && LA109_0 <= IF)||LA109_0==INT||LA109_0==INTLITERAL||(LA109_0 >= LONG && LA109_0 <= LPAREN)||(LA109_0 >= NEW && LA109_0 <= NULL)||LA109_0==PLUS||LA109_0==PLUSPLUS||LA109_0==RETURN||(LA109_0 >= SEMI && LA109_0 <= SHORT)||(LA109_0 >= STRINGLITERAL && LA109_0 <= SUB)||(LA109_0 >= SUBSUB && LA109_0 <= SYNCHRONIZED)||(LA109_0 >= THIS && LA109_0 <= THROW)||LA109_0==TILDE||(LA109_0 >= TRUE && LA109_0 <= VOID)||LA109_0==WHILE) ) {
                        alt109=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 109, 0, input);

                        throw nvae;

                    }
                    switch (alt109) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1242:13: block
                            {
                            if ( state.backtracking==0 ) { encountered.push(DO153); }

                            pushFollow(FOLLOW_block_in_statement5203);
                            block();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1242:48: statement
                            {
                            pushFollow(FOLLOW_statement_in_statement5207);
                            statement();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    WHILE154=(Token)match(input,WHILE,FOLLOW_WHILE_in_statement5210); if (state.failed) return ;

                    pushFollow(FOLLOW_parExpression_in_statement5212);
                    parExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    SEMI155=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5214); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(DO153); usa(WHILE154); usb(SEMI155); addStmt((SEMI155!=null?SEMI155.getLine():0)); }

                    }
                    break;
                case 8 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1243:9: trystatement
                    {
                    pushFollow(FOLLOW_trystatement_in_statement5226);
                    trystatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 9 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1244:9: SWITCH parExpression LBRACE switchBlockStatementGroups RBRACE
                    {
                    SWITCH156=(Token)match(input,SWITCH,FOLLOW_SWITCH_in_statement5236); if (state.failed) return ;

                    pushFollow(FOLLOW_parExpression_in_statement5238);
                    parExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    LBRACE157=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_statement5240); if (state.failed) return ;

                    pushFollow(FOLLOW_switchBlockStatementGroups_in_statement5242);
                    switchBlockStatementGroups();

                    state._fsp--;
                    if (state.failed) return ;

                    RBRACE158=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_statement5244); if (state.failed) return ;

                    if ( state.backtracking==0 ) { updateBrace(SWITCH156, LBRACE157, RBRACE158); usa(SWITCH156); }

                    }
                    break;
                case 10 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1245:9: SYNCHRONIZED parExpression block
                    {
                    SYNCHRONIZED159=(Token)match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_statement5256); if (state.failed) return ;

                    pushFollow(FOLLOW_parExpression_in_statement5258);
                    parExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    pushFollow(FOLLOW_block_in_statement5260);
                    block160=block();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { updateBrace(SYNCHRONIZED159, (block160!=null?((Token)block160.start):null), (block160!=null?((Token)block160.stop):null)); usa(SYNCHRONIZED159); }

                    }
                    break;
                case 11 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1246:9: RETURN ( expression )? SEMI
                    {
                    RETURN161=(Token)match(input,RETURN,FOLLOW_RETURN_in_statement5272); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1246:16: ( expression )?
                    int alt110=2;
                    int LA110_0 = input.LA(1);

                    if ( (LA110_0==BANG||LA110_0==BOOLEAN||LA110_0==BYTE||(LA110_0 >= CHAR && LA110_0 <= CHARLITERAL)||(LA110_0 >= DOUBLE && LA110_0 <= DOUBLELITERAL)||LA110_0==FALSE||(LA110_0 >= FLOAT && LA110_0 <= FLOATLITERAL)||LA110_0==IDENTIFIER||LA110_0==INT||LA110_0==INTLITERAL||(LA110_0 >= LONG && LA110_0 <= LPAREN)||(LA110_0 >= NEW && LA110_0 <= NULL)||LA110_0==PLUS||LA110_0==PLUSPLUS||LA110_0==SHORT||(LA110_0 >= STRINGLITERAL && LA110_0 <= SUB)||(LA110_0 >= SUBSUB && LA110_0 <= SUPER)||LA110_0==THIS||LA110_0==TILDE||LA110_0==TRUE||LA110_0==VOID) ) {
                        alt110=1;
                    }
                    switch (alt110) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1246:17: expression
                            {
                            pushFollow(FOLLOW_expression_in_statement5275);
                            expression();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    SEMI162=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5280); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(RETURN161); usb(SEMI162); addStmt((SEMI162!=null?SEMI162.getLine():0)); }

                    }
                    break;
                case 12 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1247:9: THROW expression SEMI
                    {
                    THROW163=(Token)match(input,THROW,FOLLOW_THROW_in_statement5292); if (state.failed) return ;

                    pushFollow(FOLLOW_expression_in_statement5294);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    SEMI164=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5296); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(THROW163); usb(SEMI164); addStmt((SEMI164!=null?SEMI164.getLine():0)); }

                    }
                    break;
                case 13 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1248:9: BREAK ( IDENTIFIER )? SEMI
                    {
                    BREAK165=(Token)match(input,BREAK,FOLLOW_BREAK_in_statement5308); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1249:13: ( IDENTIFIER )?
                    int alt111=2;
                    int LA111_0 = input.LA(1);

                    if ( (LA111_0==IDENTIFIER) ) {
                        alt111=1;
                    }
                    switch (alt111) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1249:14: IDENTIFIER
                            {
                            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement5323); if (state.failed) return ;

                            }
                            break;

                    }


                    SEMI166=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5340); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(BREAK165); usb(SEMI166); addStmt((SEMI166!=null?SEMI166.getLine():0)); }

                    }
                    break;
                case 14 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1252:9: CONTINUE ( IDENTIFIER )? SEMI
                    {
                    CONTINUE167=(Token)match(input,CONTINUE,FOLLOW_CONTINUE_in_statement5360); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1253:13: ( IDENTIFIER )?
                    int alt112=2;
                    int LA112_0 = input.LA(1);

                    if ( (LA112_0==IDENTIFIER) ) {
                        alt112=1;
                    }
                    switch (alt112) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1253:14: IDENTIFIER
                            {
                            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement5375); if (state.failed) return ;

                            }
                            break;

                    }


                    SEMI168=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5392); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(CONTINUE167); usb(SEMI168); addStmt((SEMI168!=null?SEMI168.getLine():0)); }

                    }
                    break;
                case 15 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1256:9: expression SEMI
                    {
                    pushFollow(FOLLOW_expression_in_statement5412);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    SEMI169=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5415); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(SEMI169); addStmt((SEMI169!=null?SEMI169.getLine():0)); }

                    }
                    break;
                case 16 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1257:9: IDENTIFIER COLON statement
                    {
                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement5427); if (state.failed) return ;

                    COLON170=(Token)match(input,COLON,FOLLOW_COLON_in_statement5429); if (state.failed) return ;

                    pushFollow(FOLLOW_statement_in_statement5431);
                    statement();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(COLON170, Key.COLON_LABEL); }

                    }
                    break;
                case 17 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1258:9: SEMI
                    {
                    SEMI171=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5443); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(SEMI171); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 59, statement_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "statement"



    // $ANTLR start "switchBlockStatementGroups"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1262:1: switchBlockStatementGroups : ( switchBlockStatementGroup )* ;
    public final void switchBlockStatementGroups() throws RecognitionException {
        int switchBlockStatementGroups_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 60) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1263:5: ( ( switchBlockStatementGroup )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1263:9: ( switchBlockStatementGroup )*
            {
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1263:9: ( switchBlockStatementGroup )*
            loop114:
            do {
                int alt114=2;
                int LA114_0 = input.LA(1);

                if ( (LA114_0==CASE||LA114_0==DEFAULT) ) {
                    alt114=1;
                }


                switch (alt114) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1263:10: switchBlockStatementGroup
            	    {
            	    pushFollow(FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups5467);
            	    switchBlockStatementGroup();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop114;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 60, switchBlockStatementGroups_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "switchBlockStatementGroups"



    // $ANTLR start "switchBlockStatementGroup"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1266:1: switchBlockStatementGroup : switchLabel ( blockStatement )* ;
    public final void switchBlockStatementGroup() throws RecognitionException {
        int switchBlockStatementGroup_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 61) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1267:5: ( switchLabel ( blockStatement )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1268:9: switchLabel ( blockStatement )*
            {
            pushFollow(FOLLOW_switchLabel_in_switchBlockStatementGroup5496);
            switchLabel();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1269:9: ( blockStatement )*
            loop115:
            do {
                int alt115=2;
                int LA115_0 = input.LA(1);

                if ( (LA115_0==ABSTRACT||(LA115_0 >= ASSERT && LA115_0 <= BANG)||(LA115_0 >= BOOLEAN && LA115_0 <= BYTE)||(LA115_0 >= CHAR && LA115_0 <= CLASS)||LA115_0==CONTINUE||LA115_0==DO||(LA115_0 >= DOUBLE && LA115_0 <= DOUBLELITERAL)||LA115_0==ENUM||(LA115_0 >= FALSE && LA115_0 <= FINAL)||(LA115_0 >= FLOAT && LA115_0 <= FOR)||(LA115_0 >= IDENTIFIER && LA115_0 <= IF)||(LA115_0 >= INT && LA115_0 <= INTLITERAL)||LA115_0==LBRACE||(LA115_0 >= LONG && LA115_0 <= LT)||(LA115_0 >= MONKEYS_AT && LA115_0 <= NULL)||LA115_0==PLUS||(LA115_0 >= PLUSPLUS && LA115_0 <= PUBLIC)||LA115_0==RETURN||(LA115_0 >= SEMI && LA115_0 <= SHORT)||(LA115_0 >= STATIC && LA115_0 <= SUB)||(LA115_0 >= SUBSUB && LA115_0 <= SYNCHRONIZED)||(LA115_0 >= THIS && LA115_0 <= THROW)||(LA115_0 >= TILDE && LA115_0 <= WHILE)) ) {
                    alt115=1;
                }


                switch (alt115) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1269:10: blockStatement
            	    {
            	    pushFollow(FOLLOW_blockStatement_in_switchBlockStatementGroup5507);
            	    blockStatement();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop115;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 61, switchBlockStatementGroup_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "switchBlockStatementGroup"



    // $ANTLR start "switchLabel"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1273:1: switchLabel : ( CASE expression COLON | DEFAULT COLON );
    public final void switchLabel() throws RecognitionException {
        int switchLabel_StartIndex = input.index();

        Token CASE172=null;
        Token COLON173=null;
        Token DEFAULT174=null;
        Token COLON175=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1274:5: ( CASE expression COLON | DEFAULT COLON )
            int alt116=2;
            int LA116_0 = input.LA(1);

            if ( (LA116_0==CASE) ) {
                alt116=1;
            }
            else if ( (LA116_0==DEFAULT) ) {
                alt116=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 116, 0, input);

                throw nvae;

            }
            switch (alt116) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1274:9: CASE expression COLON
                    {
                    CASE172=(Token)match(input,CASE,FOLLOW_CASE_in_switchLabel5538); if (state.failed) return ;

                    pushFollow(FOLLOW_expression_in_switchLabel5540);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    COLON173=(Token)match(input,COLON,FOLLOW_COLON_in_switchLabel5542); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(CASE172); usc(COLON173, Key.COLON_LABEL); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1275:9: DEFAULT COLON
                    {
                    DEFAULT174=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_switchLabel5555); if (state.failed) return ;

                    COLON175=(Token)match(input,COLON,FOLLOW_COLON_in_switchLabel5557); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(DEFAULT174, Key.DEFAULT_LABEL); usc(COLON175, Key.COLON_LABEL); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 62, switchLabel_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "switchLabel"



    // $ANTLR start "trystatement"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1278:1: trystatement : ( TRY BL= block ( catches a= FINALLY block | catches |b= FINALLY block ) | TRY resourceSpecification BL1= block ( catches c= FINALLY block | catches |d= FINALLY block )? );
    public final void trystatement() throws RecognitionException {
        int trystatement_StartIndex = input.index();

        Token a=null;
        Token b=null;
        Token c=null;
        Token d=null;
        Token TRY176=null;
        Token TRY177=null;
        JavaTypoParser.block_return BL =null;

        JavaTypoParser.block_return BL1 =null;


        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1279:5: ( TRY BL= block ( catches a= FINALLY block | catches |b= FINALLY block ) | TRY resourceSpecification BL1= block ( catches c= FINALLY block | catches |d= FINALLY block )? )
            int alt119=2;
            int LA119_0 = input.LA(1);

            if ( (LA119_0==TRY) ) {
                int LA119_1 = input.LA(2);

                if ( (LA119_1==LBRACE) ) {
                    alt119=1;
                }
                else if ( (LA119_1==LPAREN) ) {
                    alt119=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 119, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 119, 0, input);

                throw nvae;

            }
            switch (alt119) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1279:9: TRY BL= block ( catches a= FINALLY block | catches |b= FINALLY block )
                    {
                    TRY176=(Token)match(input,TRY,FOLLOW_TRY_in_trystatement5579); if (state.failed) return ;

                    if ( state.backtracking==0 ) { encountered.push(TRY176); }

                    pushFollow(FOLLOW_block_in_trystatement5585);
                    BL=block();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1280:9: ( catches a= FINALLY block | catches |b= FINALLY block )
                    int alt117=3;
                    int LA117_0 = input.LA(1);

                    if ( (LA117_0==CATCH) ) {
                        int LA117_1 = input.LA(2);

                        if ( (synpred178_JavaTypo()) ) {
                            alt117=1;
                        }
                        else if ( (synpred179_JavaTypo()) ) {
                            alt117=2;
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return ;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 117, 1, input);

                            throw nvae;

                        }
                    }
                    else if ( (LA117_0==FINALLY) ) {
                        alt117=3;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 117, 0, input);

                        throw nvae;

                    }
                    switch (alt117) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1280:13: catches a= FINALLY block
                            {
                            pushFollow(FOLLOW_catches_in_trystatement5599);
                            catches();

                            state._fsp--;
                            if (state.failed) return ;

                            a=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_trystatement5603); if (state.failed) return ;

                            if ( state.backtracking==0 ) { encountered.push(a); }

                            pushFollow(FOLLOW_block_in_trystatement5607);
                            block();

                            state._fsp--;
                            if (state.failed) return ;

                            if ( state.backtracking==0 ) { usa(a); }

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1281:13: catches
                            {
                            pushFollow(FOLLOW_catches_in_trystatement5623);
                            catches();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 3 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1282:13: b= FINALLY block
                            {
                            b=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_trystatement5639); if (state.failed) return ;

                            if ( state.backtracking==0 ) { encountered.push(b); }

                            pushFollow(FOLLOW_block_in_trystatement5643);
                            block();

                            state._fsp--;
                            if (state.failed) return ;

                            if ( state.backtracking==0 ) { usa(b); }

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { updateBrace(TRY176, (BL!=null?((Token)BL.start):null), (BL!=null?((Token)BL.stop):null)); usa(TRY176); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1285:9: TRY resourceSpecification BL1= block ( catches c= FINALLY block | catches |d= FINALLY block )?
                    {
                    TRY177=(Token)match(input,TRY,FOLLOW_TRY_in_trystatement5675); if (state.failed) return ;

                    if ( state.backtracking==0 ) { encountered.push(TRY177); }

                    pushFollow(FOLLOW_resourceSpecification_in_trystatement5679);
                    resourceSpecification();

                    state._fsp--;
                    if (state.failed) return ;

                    pushFollow(FOLLOW_block_in_trystatement5683);
                    BL1=block();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1286:5: ( catches c= FINALLY block | catches |d= FINALLY block )?
                    int alt118=4;
                    int LA118_0 = input.LA(1);

                    if ( (LA118_0==CATCH) ) {
                        int LA118_1 = input.LA(2);

                        if ( (synpred181_JavaTypo()) ) {
                            alt118=1;
                        }
                        else if ( (synpred182_JavaTypo()) ) {
                            alt118=2;
                        }
                    }
                    else if ( (LA118_0==FINALLY) ) {
                        alt118=3;
                    }
                    switch (alt118) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1286:9: catches c= FINALLY block
                            {
                            pushFollow(FOLLOW_catches_in_trystatement5693);
                            catches();

                            state._fsp--;
                            if (state.failed) return ;

                            c=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_trystatement5697); if (state.failed) return ;

                            if ( state.backtracking==0 ) { encountered.push(c); }

                            pushFollow(FOLLOW_block_in_trystatement5701);
                            block();

                            state._fsp--;
                            if (state.failed) return ;

                            if ( state.backtracking==0 ) { usa(c); }

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1287:13: catches
                            {
                            pushFollow(FOLLOW_catches_in_trystatement5717);
                            catches();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 3 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1288:13: d= FINALLY block
                            {
                            d=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_trystatement5733); if (state.failed) return ;

                            if ( state.backtracking==0 ) { encountered.push(d); }

                            pushFollow(FOLLOW_block_in_trystatement5737);
                            block();

                            state._fsp--;
                            if (state.failed) return ;

                            if ( state.backtracking==0 ) { usa(d); }

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { updateBrace(TRY177, (BL1!=null?((Token)BL1.start):null), (BL1!=null?((Token)BL1.stop):null)); usa(TRY177); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 63, trystatement_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "trystatement"



    // $ANTLR start "resourceSpecification"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1293:1: resourceSpecification : LPAREN resource (a= SEMI resource )* (b= SEMI )? RPAREN ;
    public final void resourceSpecification() throws RecognitionException {
        int resourceSpecification_StartIndex = input.index();

        Token a=null;
        Token b=null;
        Token LPAREN178=null;
        Token RPAREN179=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 64) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1294:4: ( LPAREN resource (a= SEMI resource )* (b= SEMI )? RPAREN )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1294:6: LPAREN resource (a= SEMI resource )* (b= SEMI )? RPAREN
            {
            LPAREN178=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_resourceSpecification5782); if (state.failed) return ;

            pushFollow(FOLLOW_resource_in_resourceSpecification5784);
            resource();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1294:22: (a= SEMI resource )*
            loop120:
            do {
                int alt120=2;
                int LA120_0 = input.LA(1);

                if ( (LA120_0==SEMI) ) {
                    int LA120_1 = input.LA(2);

                    if ( (LA120_1==BOOLEAN||LA120_1==BYTE||LA120_1==CHAR||LA120_1==DOUBLE||LA120_1==FINAL||LA120_1==FLOAT||LA120_1==IDENTIFIER||LA120_1==INT||LA120_1==LONG||LA120_1==MONKEYS_AT||LA120_1==SHORT) ) {
                        alt120=1;
                    }


                }


                switch (alt120) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1294:23: a= SEMI resource
            	    {
            	    a=(Token)match(input,SEMI,FOLLOW_SEMI_in_resourceSpecification5789); if (state.failed) return ;

            	    pushFollow(FOLLOW_resource_in_resourceSpecification5791);
            	    resource();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usb(a); }

            	    }
            	    break;

            	default :
            	    break loop120;
                }
            } while (true);


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1294:53: (b= SEMI )?
            int alt121=2;
            int LA121_0 = input.LA(1);

            if ( (LA121_0==SEMI) ) {
                alt121=1;
            }
            switch (alt121) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1294:54: b= SEMI
                    {
                    b=(Token)match(input,SEMI,FOLLOW_SEMI_in_resourceSpecification5800); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(b); }

                    }
                    break;

            }


            RPAREN179=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_resourceSpecification5806); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(LPAREN178); usb(RPAREN179); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 64, resourceSpecification_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "resourceSpecification"



    // $ANTLR start "resource"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1298:1: resource : variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* EQ expression ;
    public final void resource() throws RecognitionException {
        int resource_StartIndex = input.index();

        Token LBRACKET180=null;
        Token RBRACKET181=null;
        Token EQ182=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 65) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1299:5: ( variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* EQ expression )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1299:9: variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* EQ expression
            {
            pushFollow(FOLLOW_variableModifiers_in_resource5830);
            variableModifiers();

            state._fsp--;
            if (state.failed) return ;

            pushFollow(FOLLOW_type_in_resource5837);
            type();

            state._fsp--;
            if (state.failed) return ;

            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_resource5841); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1301:13: ( LBRACKET RBRACKET )*
            loop122:
            do {
                int alt122=2;
                int LA122_0 = input.LA(1);

                if ( (LA122_0==LBRACKET) ) {
                    alt122=1;
                }


                switch (alt122) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1301:14: LBRACKET RBRACKET
            	    {
            	    LBRACKET180=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_resource5844); if (state.failed) return ;

            	    RBRACKET181=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_resource5846); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(LBRACKET180); usb(RBRACKET181); }

            	    }
            	    break;

            	default :
            	    break loop122;
                }
            } while (true);


            EQ182=(Token)match(input,EQ,FOLLOW_EQ_in_resource5853); if (state.failed) return ;

            pushFollow(FOLLOW_expression_in_resource5856);
            expression();

            state._fsp--;
            if (state.failed) return ;

            if ( state.backtracking==0 ) { usc(EQ182); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 65, resource_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "resource"



    // $ANTLR start "catches"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1307:1: catches : catchClause ( catchClause )* ;
    public final void catches() throws RecognitionException {
        int catches_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 66) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1308:5: ( catchClause ( catchClause )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1308:9: catchClause ( catchClause )*
            {
            pushFollow(FOLLOW_catchClause_in_catches5879);
            catchClause();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1309:9: ( catchClause )*
            loop123:
            do {
                int alt123=2;
                int LA123_0 = input.LA(1);

                if ( (LA123_0==CATCH) ) {
                    alt123=1;
                }


                switch (alt123) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1309:10: catchClause
            	    {
            	    pushFollow(FOLLOW_catchClause_in_catches5890);
            	    catchClause();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop123;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 66, catches_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "catches"



    // $ANTLR start "catchClause"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1313:1: catchClause : CATCH LPAREN formalParameter RPAREN block ;
    public final void catchClause() throws RecognitionException {
        int catchClause_StartIndex = input.index();

        Token CATCH183=null;
        Token LPAREN184=null;
        Token RPAREN185=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 67) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1314:5: ( CATCH LPAREN formalParameter RPAREN block )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1314:9: CATCH LPAREN formalParameter RPAREN block
            {
            CATCH183=(Token)match(input,CATCH,FOLLOW_CATCH_in_catchClause5921); if (state.failed) return ;

            LPAREN184=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_catchClause5923); if (state.failed) return ;

            pushFollow(FOLLOW_formalParameter_in_catchClause5925);
            formalParameter();

            state._fsp--;
            if (state.failed) return ;

            RPAREN185=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_catchClause5935); if (state.failed) return ;

            if ( state.backtracking==0 ) { encountered.push(CATCH183); }

            pushFollow(FOLLOW_block_in_catchClause5939);
            block();

            state._fsp--;
            if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(LPAREN184); usa(CATCH183); usb(RPAREN185); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 67, catchClause_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "catchClause"



    // $ANTLR start "formalParameter"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1319:1: formalParameter : variableModifiers type ( BAR type )* IDENTIFIER ( LBRACKET RBRACKET )* ;
    public final void formalParameter() throws RecognitionException {
        int formalParameter_StartIndex = input.index();

        Token BAR186=null;
        Token LBRACKET187=null;
        Token RBRACKET188=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 68) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1320:5: ( variableModifiers type ( BAR type )* IDENTIFIER ( LBRACKET RBRACKET )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1320:9: variableModifiers type ( BAR type )* IDENTIFIER ( LBRACKET RBRACKET )*
            {
            pushFollow(FOLLOW_variableModifiers_in_formalParameter5970);
            variableModifiers();

            state._fsp--;
            if (state.failed) return ;

            pushFollow(FOLLOW_type_in_formalParameter5972);
            type();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1320:32: ( BAR type )*
            loop124:
            do {
                int alt124=2;
                int LA124_0 = input.LA(1);

                if ( (LA124_0==BAR) ) {
                    alt124=1;
                }


                switch (alt124) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1320:33: BAR type
            	    {
            	    BAR186=(Token)match(input,BAR,FOLLOW_BAR_in_formalParameter5975); if (state.failed) return ;

            	    pushFollow(FOLLOW_type_in_formalParameter5977);
            	    type();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(BAR186, Key.PIPE); }

            	    }
            	    break;

            	default :
            	    break loop124;
                }
            } while (true);


            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_formalParameter5983); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1321:9: ( LBRACKET RBRACKET )*
            loop125:
            do {
                int alt125=2;
                int LA125_0 = input.LA(1);

                if ( (LA125_0==LBRACKET) ) {
                    alt125=1;
                }


                switch (alt125) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1321:10: LBRACKET RBRACKET
            	    {
            	    LBRACKET187=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_formalParameter5994); if (state.failed) return ;

            	    RBRACKET188=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_formalParameter5996); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(LBRACKET187); usb(RBRACKET188); }

            	    }
            	    break;

            	default :
            	    break loop125;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 68, formalParameter_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "formalParameter"



    // $ANTLR start "forstatement"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1325:1: forstatement : ( FOR LPAREN variableModifiers type IDENTIFIER COLON expression RPAREN ( block | statement ) | FOR LPAREN ( forInit )? a= SEMI ( expression )? b= SEMI ( expressionList )? RPAREN ( block | statement ) );
    public final void forstatement() throws RecognitionException {
        int forstatement_StartIndex = input.index();

        Token a=null;
        Token b=null;
        Token FOR189=null;
        Token LPAREN190=null;
        Token RPAREN191=null;
        Token COLON192=null;
        Token FOR193=null;
        Token LPAREN194=null;
        Token RPAREN195=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 69) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1326:5: ( FOR LPAREN variableModifiers type IDENTIFIER COLON expression RPAREN ( block | statement ) | FOR LPAREN ( forInit )? a= SEMI ( expression )? b= SEMI ( expressionList )? RPAREN ( block | statement ) )
            int alt131=2;
            int LA131_0 = input.LA(1);

            if ( (LA131_0==FOR) ) {
                int LA131_1 = input.LA(2);

                if ( (synpred191_JavaTypo()) ) {
                    alt131=1;
                }
                else if ( (true) ) {
                    alt131=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 131, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 131, 0, input);

                throw nvae;

            }
            switch (alt131) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1328:9: FOR LPAREN variableModifiers type IDENTIFIER COLON expression RPAREN ( block | statement )
                    {
                    FOR189=(Token)match(input,FOR,FOLLOW_FOR_in_forstatement6048); if (state.failed) return ;

                    LPAREN190=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_forstatement6050); if (state.failed) return ;

                    pushFollow(FOLLOW_variableModifiers_in_forstatement6052);
                    variableModifiers();

                    state._fsp--;
                    if (state.failed) return ;

                    pushFollow(FOLLOW_type_in_forstatement6054);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_forstatement6056); if (state.failed) return ;

                    COLON192=(Token)match(input,COLON,FOLLOW_COLON_in_forstatement6058); if (state.failed) return ;

                    pushFollow(FOLLOW_expression_in_forstatement6069);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    RPAREN191=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_forstatement6071); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1329:27: ( block | statement )
                    int alt126=2;
                    int LA126_0 = input.LA(1);

                    if ( (LA126_0==LBRACE) ) {
                        int LA126_1 = input.LA(2);

                        if ( (synpred190_JavaTypo()) ) {
                            alt126=1;
                        }
                        else if ( (true) ) {
                            alt126=2;
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return ;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 126, 1, input);

                            throw nvae;

                        }
                    }
                    else if ( ((LA126_0 >= ASSERT && LA126_0 <= BANG)||(LA126_0 >= BOOLEAN && LA126_0 <= BYTE)||(LA126_0 >= CHAR && LA126_0 <= CHARLITERAL)||LA126_0==CONTINUE||LA126_0==DO||(LA126_0 >= DOUBLE && LA126_0 <= DOUBLELITERAL)||LA126_0==FALSE||(LA126_0 >= FLOAT && LA126_0 <= FOR)||(LA126_0 >= IDENTIFIER && LA126_0 <= IF)||LA126_0==INT||LA126_0==INTLITERAL||(LA126_0 >= LONG && LA126_0 <= LPAREN)||(LA126_0 >= NEW && LA126_0 <= NULL)||LA126_0==PLUS||LA126_0==PLUSPLUS||LA126_0==RETURN||(LA126_0 >= SEMI && LA126_0 <= SHORT)||(LA126_0 >= STRINGLITERAL && LA126_0 <= SUB)||(LA126_0 >= SUBSUB && LA126_0 <= SYNCHRONIZED)||(LA126_0 >= THIS && LA126_0 <= THROW)||LA126_0==TILDE||(LA126_0 >= TRUE && LA126_0 <= VOID)||LA126_0==WHILE) ) {
                        alt126=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 126, 0, input);

                        throw nvae;

                    }
                    switch (alt126) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1329:28: block
                            {
                            if ( state.backtracking==0 ) { encountered.push(FOR189); }

                            pushFollow(FOLLOW_block_in_forstatement6077);
                            block();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1329:65: statement
                            {
                            pushFollow(FOLLOW_statement_in_forstatement6081);
                            statement();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { usa(FOR189); usa(LPAREN190); usb(RPAREN191); usc(COLON192, Key.COLON_OPERATOR); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1332:9: FOR LPAREN ( forInit )? a= SEMI ( expression )? b= SEMI ( expressionList )? RPAREN ( block | statement )
                    {
                    FOR193=(Token)match(input,FOR,FOLLOW_FOR_in_forstatement6111); if (state.failed) return ;

                    LPAREN194=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_forstatement6113); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1333:17: ( forInit )?
                    int alt127=2;
                    int LA127_0 = input.LA(1);

                    if ( (LA127_0==BANG||LA127_0==BOOLEAN||LA127_0==BYTE||(LA127_0 >= CHAR && LA127_0 <= CHARLITERAL)||(LA127_0 >= DOUBLE && LA127_0 <= DOUBLELITERAL)||(LA127_0 >= FALSE && LA127_0 <= FINAL)||(LA127_0 >= FLOAT && LA127_0 <= FLOATLITERAL)||LA127_0==IDENTIFIER||LA127_0==INT||LA127_0==INTLITERAL||(LA127_0 >= LONG && LA127_0 <= LPAREN)||LA127_0==MONKEYS_AT||(LA127_0 >= NEW && LA127_0 <= NULL)||LA127_0==PLUS||LA127_0==PLUSPLUS||LA127_0==SHORT||(LA127_0 >= STRINGLITERAL && LA127_0 <= SUB)||(LA127_0 >= SUBSUB && LA127_0 <= SUPER)||LA127_0==THIS||LA127_0==TILDE||LA127_0==TRUE||LA127_0==VOID) ) {
                        alt127=1;
                    }
                    switch (alt127) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1333:18: forInit
                            {
                            pushFollow(FOLLOW_forInit_in_forstatement6133);
                            forInit();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    a=(Token)match(input,SEMI,FOLLOW_SEMI_in_forstatement6156); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(a, Key.SEMICOLON_FOR); usb(a); }

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1335:17: ( expression )?
                    int alt128=2;
                    int LA128_0 = input.LA(1);

                    if ( (LA128_0==BANG||LA128_0==BOOLEAN||LA128_0==BYTE||(LA128_0 >= CHAR && LA128_0 <= CHARLITERAL)||(LA128_0 >= DOUBLE && LA128_0 <= DOUBLELITERAL)||LA128_0==FALSE||(LA128_0 >= FLOAT && LA128_0 <= FLOATLITERAL)||LA128_0==IDENTIFIER||LA128_0==INT||LA128_0==INTLITERAL||(LA128_0 >= LONG && LA128_0 <= LPAREN)||(LA128_0 >= NEW && LA128_0 <= NULL)||LA128_0==PLUS||LA128_0==PLUSPLUS||LA128_0==SHORT||(LA128_0 >= STRINGLITERAL && LA128_0 <= SUB)||(LA128_0 >= SUBSUB && LA128_0 <= SUPER)||LA128_0==THIS||LA128_0==TILDE||LA128_0==TRUE||LA128_0==VOID) ) {
                        alt128=1;
                    }
                    switch (alt128) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1335:18: expression
                            {
                            pushFollow(FOLLOW_expression_in_forstatement6177);
                            expression();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    b=(Token)match(input,SEMI,FOLLOW_SEMI_in_forstatement6200); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(b, Key.SEMICOLON_FOR); usb(b); }

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1337:17: ( expressionList )?
                    int alt129=2;
                    int LA129_0 = input.LA(1);

                    if ( (LA129_0==BANG||LA129_0==BOOLEAN||LA129_0==BYTE||(LA129_0 >= CHAR && LA129_0 <= CHARLITERAL)||(LA129_0 >= DOUBLE && LA129_0 <= DOUBLELITERAL)||LA129_0==FALSE||(LA129_0 >= FLOAT && LA129_0 <= FLOATLITERAL)||LA129_0==IDENTIFIER||LA129_0==INT||LA129_0==INTLITERAL||(LA129_0 >= LONG && LA129_0 <= LPAREN)||(LA129_0 >= NEW && LA129_0 <= NULL)||LA129_0==PLUS||LA129_0==PLUSPLUS||LA129_0==SHORT||(LA129_0 >= STRINGLITERAL && LA129_0 <= SUB)||(LA129_0 >= SUBSUB && LA129_0 <= SUPER)||LA129_0==THIS||LA129_0==TILDE||LA129_0==TRUE||LA129_0==VOID) ) {
                        alt129=1;
                    }
                    switch (alt129) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1337:18: expressionList
                            {
                            pushFollow(FOLLOW_expressionList_in_forstatement6221);
                            expressionList();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    RPAREN195=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_forstatement6242); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1338:27: ( block | statement )
                    int alt130=2;
                    int LA130_0 = input.LA(1);

                    if ( (LA130_0==LBRACE) ) {
                        int LA130_1 = input.LA(2);

                        if ( (synpred195_JavaTypo()) ) {
                            alt130=1;
                        }
                        else if ( (true) ) {
                            alt130=2;
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return ;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 130, 1, input);

                            throw nvae;

                        }
                    }
                    else if ( ((LA130_0 >= ASSERT && LA130_0 <= BANG)||(LA130_0 >= BOOLEAN && LA130_0 <= BYTE)||(LA130_0 >= CHAR && LA130_0 <= CHARLITERAL)||LA130_0==CONTINUE||LA130_0==DO||(LA130_0 >= DOUBLE && LA130_0 <= DOUBLELITERAL)||LA130_0==FALSE||(LA130_0 >= FLOAT && LA130_0 <= FOR)||(LA130_0 >= IDENTIFIER && LA130_0 <= IF)||LA130_0==INT||LA130_0==INTLITERAL||(LA130_0 >= LONG && LA130_0 <= LPAREN)||(LA130_0 >= NEW && LA130_0 <= NULL)||LA130_0==PLUS||LA130_0==PLUSPLUS||LA130_0==RETURN||(LA130_0 >= SEMI && LA130_0 <= SHORT)||(LA130_0 >= STRINGLITERAL && LA130_0 <= SUB)||(LA130_0 >= SUBSUB && LA130_0 <= SYNCHRONIZED)||(LA130_0 >= THIS && LA130_0 <= THROW)||LA130_0==TILDE||(LA130_0 >= TRUE && LA130_0 <= VOID)||LA130_0==WHILE) ) {
                        alt130=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 130, 0, input);

                        throw nvae;

                    }
                    switch (alt130) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1338:28: block
                            {
                            if ( state.backtracking==0 ) { encountered.push(FOR193); }

                            pushFollow(FOLLOW_block_in_forstatement6248);
                            block();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1338:65: statement
                            {
                            pushFollow(FOLLOW_statement_in_forstatement6252);
                            statement();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { usa(FOR193); usa(LPAREN194); usb(RPAREN195); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 69, forstatement_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "forstatement"



    // $ANTLR start "forInit"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1342:1: forInit : ( variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ variableInitializer )? ( COMMA variableDeclarator )* | expressionList );
    public final void forInit() throws RecognitionException {
        int forInit_StartIndex = input.index();

        Token LBRACKET196=null;
        Token RBRACKET197=null;
        Token EQ198=null;
        Token COMMA199=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 70) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1343:5: ( variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ variableInitializer )? ( COMMA variableDeclarator )* | expressionList )
            int alt135=2;
            switch ( input.LA(1) ) {
            case FINAL:
            case MONKEYS_AT:
                {
                alt135=1;
                }
                break;
            case IDENTIFIER:
                {
                int LA135_3 = input.LA(2);

                if ( (synpred199_JavaTypo()) ) {
                    alt135=1;
                }
                else if ( (true) ) {
                    alt135=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 135, 3, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
                {
                int LA135_4 = input.LA(2);

                if ( (synpred199_JavaTypo()) ) {
                    alt135=1;
                }
                else if ( (true) ) {
                    alt135=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 135, 4, input);

                    throw nvae;

                }
                }
                break;
            case CHAR:
                {
                int LA135_5 = input.LA(2);

                if ( (synpred199_JavaTypo()) ) {
                    alt135=1;
                }
                else if ( (true) ) {
                    alt135=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 135, 5, input);

                    throw nvae;

                }
                }
                break;
            case BYTE:
                {
                int LA135_6 = input.LA(2);

                if ( (synpred199_JavaTypo()) ) {
                    alt135=1;
                }
                else if ( (true) ) {
                    alt135=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 135, 6, input);

                    throw nvae;

                }
                }
                break;
            case SHORT:
                {
                int LA135_7 = input.LA(2);

                if ( (synpred199_JavaTypo()) ) {
                    alt135=1;
                }
                else if ( (true) ) {
                    alt135=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 135, 7, input);

                    throw nvae;

                }
                }
                break;
            case INT:
                {
                int LA135_8 = input.LA(2);

                if ( (synpred199_JavaTypo()) ) {
                    alt135=1;
                }
                else if ( (true) ) {
                    alt135=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 135, 8, input);

                    throw nvae;

                }
                }
                break;
            case LONG:
                {
                int LA135_9 = input.LA(2);

                if ( (synpred199_JavaTypo()) ) {
                    alt135=1;
                }
                else if ( (true) ) {
                    alt135=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 135, 9, input);

                    throw nvae;

                }
                }
                break;
            case FLOAT:
                {
                int LA135_10 = input.LA(2);

                if ( (synpred199_JavaTypo()) ) {
                    alt135=1;
                }
                else if ( (true) ) {
                    alt135=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 135, 10, input);

                    throw nvae;

                }
                }
                break;
            case DOUBLE:
                {
                int LA135_11 = input.LA(2);

                if ( (synpred199_JavaTypo()) ) {
                    alt135=1;
                }
                else if ( (true) ) {
                    alt135=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 135, 11, input);

                    throw nvae;

                }
                }
                break;
            case BANG:
            case CHARLITERAL:
            case DOUBLELITERAL:
            case FALSE:
            case FLOATLITERAL:
            case INTLITERAL:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case PLUS:
            case PLUSPLUS:
            case STRINGLITERAL:
            case SUB:
            case SUBSUB:
            case SUPER:
            case THIS:
            case TILDE:
            case TRUE:
            case VOID:
                {
                alt135=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 135, 0, input);

                throw nvae;

            }

            switch (alt135) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1343:9: variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ variableInitializer )? ( COMMA variableDeclarator )*
                    {
                    pushFollow(FOLLOW_variableModifiers_in_forInit6283);
                    variableModifiers();

                    state._fsp--;
                    if (state.failed) return ;

                    pushFollow(FOLLOW_type_in_forInit6285);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_forInit6295); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1345:9: ( LBRACKET RBRACKET )*
                    loop132:
                    do {
                        int alt132=2;
                        int LA132_0 = input.LA(1);

                        if ( (LA132_0==LBRACKET) ) {
                            alt132=1;
                        }


                        switch (alt132) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1345:10: LBRACKET RBRACKET
                    	    {
                    	    LBRACKET196=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_forInit6306); if (state.failed) return ;

                    	    RBRACKET197=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_forInit6308); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usa(LBRACKET196); usb(RBRACKET197); }

                    	    }
                    	    break;

                    	default :
                    	    break loop132;
                        }
                    } while (true);


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1347:9: ( EQ variableInitializer )?
                    int alt133=2;
                    int LA133_0 = input.LA(1);

                    if ( (LA133_0==EQ) ) {
                        alt133=1;
                    }
                    switch (alt133) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1347:10: EQ variableInitializer
                            {
                            EQ198=(Token)match(input,EQ,FOLLOW_EQ_in_forInit6332); if (state.failed) return ;

                            pushFollow(FOLLOW_variableInitializer_in_forInit6334);
                            variableInitializer();

                            state._fsp--;
                            if (state.failed) return ;

                            if ( state.backtracking==0 ) { usc(EQ198); }

                            }
                            break;

                    }


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1349:9: ( COMMA variableDeclarator )*
                    loop134:
                    do {
                        int alt134=2;
                        int LA134_0 = input.LA(1);

                        if ( (LA134_0==COMMA) ) {
                            alt134=1;
                        }


                        switch (alt134) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1349:10: COMMA variableDeclarator
                    	    {
                    	    COMMA199=(Token)match(input,COMMA,FOLLOW_COMMA_in_forInit6358); if (state.failed) return ;

                    	    pushFollow(FOLLOW_variableDeclarator_in_forInit6360);
                    	    variableDeclarator();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usc(COMMA199); }

                    	    }
                    	    break;

                    	default :
                    	    break loop134;
                        }
                    } while (true);


                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1353:9: expressionList
                    {
                    pushFollow(FOLLOW_expressionList_in_forInit6401);
                    expressionList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 70, forInit_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "forInit"



    // $ANTLR start "parExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1356:1: parExpression : LPAREN expression RPAREN ;
    public final void parExpression() throws RecognitionException {
        int parExpression_StartIndex = input.index();

        Token LPAREN200=null;
        Token RPAREN201=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 71) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1357:5: ( LPAREN expression RPAREN )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1357:9: LPAREN expression RPAREN
            {
            LPAREN200=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_parExpression6421); if (state.failed) return ;

            pushFollow(FOLLOW_expression_in_parExpression6423);
            expression();

            state._fsp--;
            if (state.failed) return ;

            RPAREN201=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_parExpression6425); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(LPAREN200); usb(RPAREN201); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 71, parExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "parExpression"



    // $ANTLR start "expressionList"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1360:1: expressionList : expression ( COMMA expression )* ;
    public final void expressionList() throws RecognitionException {
        int expressionList_StartIndex = input.index();

        Token COMMA202=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 72) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1361:5: ( expression ( COMMA expression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1361:9: expression ( COMMA expression )*
            {
            pushFollow(FOLLOW_expression_in_expressionList6447);
            expression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1362:9: ( COMMA expression )*
            loop136:
            do {
                int alt136=2;
                int LA136_0 = input.LA(1);

                if ( (LA136_0==COMMA) ) {
                    alt136=1;
                }


                switch (alt136) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1362:10: COMMA expression
            	    {
            	    COMMA202=(Token)match(input,COMMA,FOLLOW_COMMA_in_expressionList6458); if (state.failed) return ;

            	    pushFollow(FOLLOW_expression_in_expressionList6460);
            	    expression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(COMMA202); }

            	    }
            	    break;

            	default :
            	    break loop136;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 72, expressionList_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "expressionList"



    // $ANTLR start "expression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1367:1: expression : conditionalExpression ( assignmentOperator expression )? ;
    public final void expression() throws RecognitionException {
        int expression_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 73) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1368:5: ( conditionalExpression ( assignmentOperator expression )? )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1368:9: conditionalExpression ( assignmentOperator expression )?
            {
            pushFollow(FOLLOW_conditionalExpression_in_expression6494);
            conditionalExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1369:9: ( assignmentOperator expression )?
            int alt137=2;
            int LA137_0 = input.LA(1);

            if ( (LA137_0==AMPEQ||LA137_0==BAREQ||LA137_0==CARETEQ||LA137_0==EQ||LA137_0==GT||LA137_0==LT||LA137_0==PERCENTEQ||LA137_0==PLUSEQ||LA137_0==SLASHEQ||LA137_0==STAREQ||LA137_0==SUBEQ) ) {
                alt137=1;
            }
            switch (alt137) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1369:10: assignmentOperator expression
                    {
                    pushFollow(FOLLOW_assignmentOperator_in_expression6505);
                    assignmentOperator();

                    state._fsp--;
                    if (state.failed) return ;

                    pushFollow(FOLLOW_expression_in_expression6507);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 73, expression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "expression"



    // $ANTLR start "assignmentOperator"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1374:1: assignmentOperator : ( EQ | PLUSEQ | SUBEQ | STAREQ | SLASHEQ | AMPEQ | BAREQ | CARETEQ | PERCENTEQ | LT '<' EQ | GT '>' '>' EQ | GT '>' EQ );
    public final void assignmentOperator() throws RecognitionException {
        int assignmentOperator_StartIndex = input.index();

        Token EQ203=null;
        Token PLUSEQ204=null;
        Token SUBEQ205=null;
        Token STAREQ206=null;
        Token SLASHEQ207=null;
        Token AMPEQ208=null;
        Token BAREQ209=null;
        Token CARETEQ210=null;
        Token PERCENTEQ211=null;
        Token LT212=null;
        Token EQ213=null;
        Token GT214=null;
        Token EQ215=null;
        Token GT216=null;
        Token EQ217=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 74) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1375:5: ( EQ | PLUSEQ | SUBEQ | STAREQ | SLASHEQ | AMPEQ | BAREQ | CARETEQ | PERCENTEQ | LT '<' EQ | GT '>' '>' EQ | GT '>' EQ )
            int alt138=12;
            switch ( input.LA(1) ) {
            case EQ:
                {
                alt138=1;
                }
                break;
            case PLUSEQ:
                {
                alt138=2;
                }
                break;
            case SUBEQ:
                {
                alt138=3;
                }
                break;
            case STAREQ:
                {
                alt138=4;
                }
                break;
            case SLASHEQ:
                {
                alt138=5;
                }
                break;
            case AMPEQ:
                {
                alt138=6;
                }
                break;
            case BAREQ:
                {
                alt138=7;
                }
                break;
            case CARETEQ:
                {
                alt138=8;
                }
                break;
            case PERCENTEQ:
                {
                alt138=9;
                }
                break;
            case LT:
                {
                alt138=10;
                }
                break;
            case GT:
                {
                int LA138_11 = input.LA(2);

                if ( (LA138_11==GT) ) {
                    int LA138_12 = input.LA(3);

                    if ( (LA138_12==GT) ) {
                        alt138=11;
                    }
                    else if ( (LA138_12==EQ) ) {
                        alt138=12;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 138, 12, input);

                        throw nvae;

                    }
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 138, 11, input);

                    throw nvae;

                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 138, 0, input);

                throw nvae;

            }

            switch (alt138) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1375:9: EQ
                    {
                    EQ203=(Token)match(input,EQ,FOLLOW_EQ_in_assignmentOperator6539); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(EQ203); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1376:9: PLUSEQ
                    {
                    PLUSEQ204=(Token)match(input,PLUSEQ,FOLLOW_PLUSEQ_in_assignmentOperator6553); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(PLUSEQ204); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1377:9: SUBEQ
                    {
                    SUBEQ205=(Token)match(input,SUBEQ,FOLLOW_SUBEQ_in_assignmentOperator6567); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(SUBEQ205); }

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1378:9: STAREQ
                    {
                    STAREQ206=(Token)match(input,STAREQ,FOLLOW_STAREQ_in_assignmentOperator6581); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(STAREQ206); }

                    }
                    break;
                case 5 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1379:9: SLASHEQ
                    {
                    SLASHEQ207=(Token)match(input,SLASHEQ,FOLLOW_SLASHEQ_in_assignmentOperator6595); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(SLASHEQ207); }

                    }
                    break;
                case 6 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1380:9: AMPEQ
                    {
                    AMPEQ208=(Token)match(input,AMPEQ,FOLLOW_AMPEQ_in_assignmentOperator6609); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(AMPEQ208); }

                    }
                    break;
                case 7 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1381:9: BAREQ
                    {
                    BAREQ209=(Token)match(input,BAREQ,FOLLOW_BAREQ_in_assignmentOperator6623); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(BAREQ209); }

                    }
                    break;
                case 8 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1382:9: CARETEQ
                    {
                    CARETEQ210=(Token)match(input,CARETEQ,FOLLOW_CARETEQ_in_assignmentOperator6637); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(CARETEQ210); }

                    }
                    break;
                case 9 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1383:9: PERCENTEQ
                    {
                    PERCENTEQ211=(Token)match(input,PERCENTEQ,FOLLOW_PERCENTEQ_in_assignmentOperator6651); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(PERCENTEQ211); }

                    }
                    break;
                case 10 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1384:10: LT '<' EQ
                    {
                    LT212=(Token)match(input,LT,FOLLOW_LT_in_assignmentOperator6665); if (state.failed) return ;

                    match(input,LT,FOLLOW_LT_in_assignmentOperator6667); if (state.failed) return ;

                    EQ213=(Token)match(input,EQ,FOLLOW_EQ_in_assignmentOperator6669); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(LT212, Key.LSHIFT_EQ); usa(EQ213, Key.LSHIFT_EQ); }

                    }
                    break;
                case 11 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1385:10: GT '>' '>' EQ
                    {
                    GT214=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator6683); if (state.failed) return ;

                    match(input,GT,FOLLOW_GT_in_assignmentOperator6685); if (state.failed) return ;

                    match(input,GT,FOLLOW_GT_in_assignmentOperator6687); if (state.failed) return ;

                    EQ215=(Token)match(input,EQ,FOLLOW_EQ_in_assignmentOperator6689); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(GT214, Key.URSHIFT_EQ); usa(EQ215, Key.URSHIFT_EQ); }

                    }
                    break;
                case 12 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1386:10: GT '>' EQ
                    {
                    GT216=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator6703); if (state.failed) return ;

                    match(input,GT,FOLLOW_GT_in_assignmentOperator6705); if (state.failed) return ;

                    EQ217=(Token)match(input,EQ,FOLLOW_EQ_in_assignmentOperator6707); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(GT216, Key.RSHIFT_EQ); usa(EQ217, Key.RSHIFT_EQ); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 74, assignmentOperator_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "assignmentOperator"



    // $ANTLR start "conditionalExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1390:1: conditionalExpression : conditionalOrExpression ( QUES expression COLON conditionalExpression )? ;
    public final void conditionalExpression() throws RecognitionException {
        int conditionalExpression_StartIndex = input.index();

        Token QUES218=null;
        Token COLON219=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 75) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1391:5: ( conditionalOrExpression ( QUES expression COLON conditionalExpression )? )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1391:9: conditionalOrExpression ( QUES expression COLON conditionalExpression )?
            {
            pushFollow(FOLLOW_conditionalOrExpression_in_conditionalExpression6731);
            conditionalOrExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1392:9: ( QUES expression COLON conditionalExpression )?
            int alt139=2;
            int LA139_0 = input.LA(1);

            if ( (LA139_0==QUES) ) {
                alt139=1;
            }
            switch (alt139) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1392:10: QUES expression COLON conditionalExpression
                    {
                    QUES218=(Token)match(input,QUES,FOLLOW_QUES_in_conditionalExpression6742); if (state.failed) return ;

                    pushFollow(FOLLOW_expression_in_conditionalExpression6744);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    COLON219=(Token)match(input,COLON,FOLLOW_COLON_in_conditionalExpression6746); if (state.failed) return ;

                    pushFollow(FOLLOW_conditionalExpression_in_conditionalExpression6748);
                    conditionalExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(QUES218); usc(COLON219, Key.COLON_OPERATOR); }

                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 75, conditionalExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "conditionalExpression"



    // $ANTLR start "conditionalOrExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1396:1: conditionalOrExpression : conditionalAndExpression ( BARBAR conditionalAndExpression )* ;
    public final void conditionalOrExpression() throws RecognitionException {
        int conditionalOrExpression_StartIndex = input.index();

        Token BARBAR220=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 76) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1397:5: ( conditionalAndExpression ( BARBAR conditionalAndExpression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1397:9: conditionalAndExpression ( BARBAR conditionalAndExpression )*
            {
            pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression6781);
            conditionalAndExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1398:9: ( BARBAR conditionalAndExpression )*
            loop140:
            do {
                int alt140=2;
                int LA140_0 = input.LA(1);

                if ( (LA140_0==BARBAR) ) {
                    alt140=1;
                }


                switch (alt140) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1398:10: BARBAR conditionalAndExpression
            	    {
            	    BARBAR220=(Token)match(input,BARBAR,FOLLOW_BARBAR_in_conditionalOrExpression6792); if (state.failed) return ;

            	    pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression6794);
            	    conditionalAndExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(BARBAR220); }

            	    }
            	    break;

            	default :
            	    break loop140;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 76, conditionalOrExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "conditionalOrExpression"



    // $ANTLR start "conditionalAndExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1402:1: conditionalAndExpression : inclusiveOrExpression ( AMPAMP inclusiveOrExpression )* ;
    public final void conditionalAndExpression() throws RecognitionException {
        int conditionalAndExpression_StartIndex = input.index();

        Token AMPAMP221=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 77) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1403:5: ( inclusiveOrExpression ( AMPAMP inclusiveOrExpression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1403:9: inclusiveOrExpression ( AMPAMP inclusiveOrExpression )*
            {
            pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression6827);
            inclusiveOrExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1404:9: ( AMPAMP inclusiveOrExpression )*
            loop141:
            do {
                int alt141=2;
                int LA141_0 = input.LA(1);

                if ( (LA141_0==AMPAMP) ) {
                    alt141=1;
                }


                switch (alt141) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1404:10: AMPAMP inclusiveOrExpression
            	    {
            	    AMPAMP221=(Token)match(input,AMPAMP,FOLLOW_AMPAMP_in_conditionalAndExpression6838); if (state.failed) return ;

            	    pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression6840);
            	    inclusiveOrExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(AMPAMP221); }

            	    }
            	    break;

            	default :
            	    break loop141;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 77, conditionalAndExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "conditionalAndExpression"



    // $ANTLR start "inclusiveOrExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1408:1: inclusiveOrExpression : exclusiveOrExpression ( BAR exclusiveOrExpression )* ;
    public final void inclusiveOrExpression() throws RecognitionException {
        int inclusiveOrExpression_StartIndex = input.index();

        Token BAR222=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 78) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1409:5: ( exclusiveOrExpression ( BAR exclusiveOrExpression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1409:9: exclusiveOrExpression ( BAR exclusiveOrExpression )*
            {
            pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression6873);
            exclusiveOrExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1410:9: ( BAR exclusiveOrExpression )*
            loop142:
            do {
                int alt142=2;
                int LA142_0 = input.LA(1);

                if ( (LA142_0==BAR) ) {
                    alt142=1;
                }


                switch (alt142) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1410:10: BAR exclusiveOrExpression
            	    {
            	    BAR222=(Token)match(input,BAR,FOLLOW_BAR_in_inclusiveOrExpression6884); if (state.failed) return ;

            	    pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression6886);
            	    exclusiveOrExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(BAR222, Key.OR); }

            	    }
            	    break;

            	default :
            	    break loop142;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 78, inclusiveOrExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "inclusiveOrExpression"



    // $ANTLR start "exclusiveOrExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1414:1: exclusiveOrExpression : andExpression ( CARET andExpression )* ;
    public final void exclusiveOrExpression() throws RecognitionException {
        int exclusiveOrExpression_StartIndex = input.index();

        Token CARET223=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 79) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1415:5: ( andExpression ( CARET andExpression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1415:9: andExpression ( CARET andExpression )*
            {
            pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression6919);
            andExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1416:9: ( CARET andExpression )*
            loop143:
            do {
                int alt143=2;
                int LA143_0 = input.LA(1);

                if ( (LA143_0==CARET) ) {
                    alt143=1;
                }


                switch (alt143) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1416:10: CARET andExpression
            	    {
            	    CARET223=(Token)match(input,CARET,FOLLOW_CARET_in_exclusiveOrExpression6930); if (state.failed) return ;

            	    pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression6932);
            	    andExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(CARET223); }

            	    }
            	    break;

            	default :
            	    break loop143;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 79, exclusiveOrExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "exclusiveOrExpression"



    // $ANTLR start "andExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1420:1: andExpression : equalityExpression ( AMP equalityExpression )* ;
    public final void andExpression() throws RecognitionException {
        int andExpression_StartIndex = input.index();

        Token AMP224=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 80) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1421:5: ( equalityExpression ( AMP equalityExpression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1421:9: equalityExpression ( AMP equalityExpression )*
            {
            pushFollow(FOLLOW_equalityExpression_in_andExpression6965);
            equalityExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1422:9: ( AMP equalityExpression )*
            loop144:
            do {
                int alt144=2;
                int LA144_0 = input.LA(1);

                if ( (LA144_0==AMP) ) {
                    alt144=1;
                }


                switch (alt144) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1422:10: AMP equalityExpression
            	    {
            	    AMP224=(Token)match(input,AMP,FOLLOW_AMP_in_andExpression6976); if (state.failed) return ;

            	    pushFollow(FOLLOW_equalityExpression_in_andExpression6978);
            	    equalityExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usc(AMP224, Key.AND); }

            	    }
            	    break;

            	default :
            	    break loop144;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 80, andExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "andExpression"



    // $ANTLR start "equalityExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1426:1: equalityExpression : instanceOfExpression ( ( EQEQ | BANGEQ ) instanceOfExpression )* ;
    public final void equalityExpression() throws RecognitionException {
        int equalityExpression_StartIndex = input.index();

        Token EQEQ225=null;
        Token BANGEQ226=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 81) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1427:5: ( instanceOfExpression ( ( EQEQ | BANGEQ ) instanceOfExpression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1427:9: instanceOfExpression ( ( EQEQ | BANGEQ ) instanceOfExpression )*
            {
            pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression7011);
            instanceOfExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1428:9: ( ( EQEQ | BANGEQ ) instanceOfExpression )*
            loop146:
            do {
                int alt146=2;
                int LA146_0 = input.LA(1);

                if ( (LA146_0==BANGEQ||LA146_0==EQEQ) ) {
                    alt146=1;
                }


                switch (alt146) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1429:13: ( EQEQ | BANGEQ ) instanceOfExpression
            	    {
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1429:13: ( EQEQ | BANGEQ )
            	    int alt145=2;
            	    int LA145_0 = input.LA(1);

            	    if ( (LA145_0==EQEQ) ) {
            	        alt145=1;
            	    }
            	    else if ( (LA145_0==BANGEQ) ) {
            	        alt145=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 145, 0, input);

            	        throw nvae;

            	    }
            	    switch (alt145) {
            	        case 1 :
            	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1429:17: EQEQ
            	            {
            	            EQEQ225=(Token)match(input,EQEQ,FOLLOW_EQEQ_in_equalityExpression7042); if (state.failed) return ;

            	            if ( state.backtracking==0 ) { usc(EQEQ225); }

            	            }
            	            break;
            	        case 2 :
            	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1430:17: BANGEQ
            	            {
            	            BANGEQ226=(Token)match(input,BANGEQ,FOLLOW_BANGEQ_in_equalityExpression7062); if (state.failed) return ;

            	            if ( state.backtracking==0 ) { usc(BANGEQ226); }

            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression7092);
            	    instanceOfExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop146;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 81, equalityExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "equalityExpression"



    // $ANTLR start "instanceOfExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1436:1: instanceOfExpression : relationalExpression ( INSTANCEOF type )? ;
    public final void instanceOfExpression() throws RecognitionException {
        int instanceOfExpression_StartIndex = input.index();

        Token INSTANCEOF227=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 82) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1437:5: ( relationalExpression ( INSTANCEOF type )? )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1437:9: relationalExpression ( INSTANCEOF type )?
            {
            pushFollow(FOLLOW_relationalExpression_in_instanceOfExpression7123);
            relationalExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1438:9: ( INSTANCEOF type )?
            int alt147=2;
            int LA147_0 = input.LA(1);

            if ( (LA147_0==INSTANCEOF) ) {
                alt147=1;
            }
            switch (alt147) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1438:10: INSTANCEOF type
                    {
                    INSTANCEOF227=(Token)match(input,INSTANCEOF,FOLLOW_INSTANCEOF_in_instanceOfExpression7134); if (state.failed) return ;

                    pushFollow(FOLLOW_type_in_instanceOfExpression7136);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(INSTANCEOF227); }

                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 82, instanceOfExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "instanceOfExpression"



    // $ANTLR start "relationalExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1442:1: relationalExpression : shiftExpression ( relationalOp shiftExpression )* ;
    public final void relationalExpression() throws RecognitionException {
        int relationalExpression_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 83) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1443:5: ( shiftExpression ( relationalOp shiftExpression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1443:9: shiftExpression ( relationalOp shiftExpression )*
            {
            pushFollow(FOLLOW_shiftExpression_in_relationalExpression7169);
            shiftExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1444:9: ( relationalOp shiftExpression )*
            loop148:
            do {
                int alt148=2;
                int LA148_0 = input.LA(1);

                if ( (LA148_0==LT) ) {
                    int LA148_2 = input.LA(2);

                    if ( (LA148_2==BANG||LA148_2==BOOLEAN||LA148_2==BYTE||(LA148_2 >= CHAR && LA148_2 <= CHARLITERAL)||(LA148_2 >= DOUBLE && LA148_2 <= DOUBLELITERAL)||LA148_2==EQ||LA148_2==FALSE||(LA148_2 >= FLOAT && LA148_2 <= FLOATLITERAL)||LA148_2==IDENTIFIER||LA148_2==INT||LA148_2==INTLITERAL||(LA148_2 >= LONG && LA148_2 <= LPAREN)||(LA148_2 >= NEW && LA148_2 <= NULL)||LA148_2==PLUS||LA148_2==PLUSPLUS||LA148_2==SHORT||(LA148_2 >= STRINGLITERAL && LA148_2 <= SUB)||(LA148_2 >= SUBSUB && LA148_2 <= SUPER)||LA148_2==THIS||LA148_2==TILDE||LA148_2==TRUE||LA148_2==VOID) ) {
                        alt148=1;
                    }


                }
                else if ( (LA148_0==GT) ) {
                    int LA148_3 = input.LA(2);

                    if ( (LA148_3==BANG||LA148_3==BOOLEAN||LA148_3==BYTE||(LA148_3 >= CHAR && LA148_3 <= CHARLITERAL)||(LA148_3 >= DOUBLE && LA148_3 <= DOUBLELITERAL)||LA148_3==EQ||LA148_3==FALSE||(LA148_3 >= FLOAT && LA148_3 <= FLOATLITERAL)||LA148_3==IDENTIFIER||LA148_3==INT||LA148_3==INTLITERAL||(LA148_3 >= LONG && LA148_3 <= LPAREN)||(LA148_3 >= NEW && LA148_3 <= NULL)||LA148_3==PLUS||LA148_3==PLUSPLUS||LA148_3==SHORT||(LA148_3 >= STRINGLITERAL && LA148_3 <= SUB)||(LA148_3 >= SUBSUB && LA148_3 <= SUPER)||LA148_3==THIS||LA148_3==TILDE||LA148_3==TRUE||LA148_3==VOID) ) {
                        alt148=1;
                    }


                }


                switch (alt148) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1444:10: relationalOp shiftExpression
            	    {
            	    pushFollow(FOLLOW_relationalOp_in_relationalExpression7180);
            	    relationalOp();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    pushFollow(FOLLOW_shiftExpression_in_relationalExpression7182);
            	    shiftExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop148;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 83, relationalExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "relationalExpression"



    // $ANTLR start "relationalOp"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1448:1: relationalOp : ( LT EQ | GT EQ | LT | GT );
    public final void relationalOp() throws RecognitionException {
        int relationalOp_StartIndex = input.index();

        Token LT228=null;
        Token EQ229=null;
        Token GT230=null;
        Token EQ231=null;
        Token LT232=null;
        Token GT233=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 84) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1449:5: ( LT EQ | GT EQ | LT | GT )
            int alt149=4;
            int LA149_0 = input.LA(1);

            if ( (LA149_0==LT) ) {
                int LA149_1 = input.LA(2);

                if ( (LA149_1==EQ) ) {
                    alt149=1;
                }
                else if ( (LA149_1==BANG||LA149_1==BOOLEAN||LA149_1==BYTE||(LA149_1 >= CHAR && LA149_1 <= CHARLITERAL)||(LA149_1 >= DOUBLE && LA149_1 <= DOUBLELITERAL)||LA149_1==FALSE||(LA149_1 >= FLOAT && LA149_1 <= FLOATLITERAL)||LA149_1==IDENTIFIER||LA149_1==INT||LA149_1==INTLITERAL||(LA149_1 >= LONG && LA149_1 <= LPAREN)||(LA149_1 >= NEW && LA149_1 <= NULL)||LA149_1==PLUS||LA149_1==PLUSPLUS||LA149_1==SHORT||(LA149_1 >= STRINGLITERAL && LA149_1 <= SUB)||(LA149_1 >= SUBSUB && LA149_1 <= SUPER)||LA149_1==THIS||LA149_1==TILDE||LA149_1==TRUE||LA149_1==VOID) ) {
                    alt149=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 149, 1, input);

                    throw nvae;

                }
            }
            else if ( (LA149_0==GT) ) {
                int LA149_2 = input.LA(2);

                if ( (LA149_2==EQ) ) {
                    alt149=2;
                }
                else if ( (LA149_2==BANG||LA149_2==BOOLEAN||LA149_2==BYTE||(LA149_2 >= CHAR && LA149_2 <= CHARLITERAL)||(LA149_2 >= DOUBLE && LA149_2 <= DOUBLELITERAL)||LA149_2==FALSE||(LA149_2 >= FLOAT && LA149_2 <= FLOATLITERAL)||LA149_2==IDENTIFIER||LA149_2==INT||LA149_2==INTLITERAL||(LA149_2 >= LONG && LA149_2 <= LPAREN)||(LA149_2 >= NEW && LA149_2 <= NULL)||LA149_2==PLUS||LA149_2==PLUSPLUS||LA149_2==SHORT||(LA149_2 >= STRINGLITERAL && LA149_2 <= SUB)||(LA149_2 >= SUBSUB && LA149_2 <= SUPER)||LA149_2==THIS||LA149_2==TILDE||LA149_2==TRUE||LA149_2==VOID) ) {
                    alt149=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 149, 2, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 149, 0, input);

                throw nvae;

            }
            switch (alt149) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1449:10: LT EQ
                    {
                    LT228=(Token)match(input,LT,FOLLOW_LT_in_relationalOp7214); if (state.failed) return ;

                    EQ229=(Token)match(input,EQ,FOLLOW_EQ_in_relationalOp7216); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(LT228, Key.LTE); usa(EQ229, Key.LTE); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1450:10: GT EQ
                    {
                    GT230=(Token)match(input,GT,FOLLOW_GT_in_relationalOp7229); if (state.failed) return ;

                    EQ231=(Token)match(input,EQ,FOLLOW_EQ_in_relationalOp7231); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(GT230, Key.GTE); usa(EQ231, Key.GTE); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1451:10: LT
                    {
                    LT232=(Token)match(input,LT,FOLLOW_LT_in_relationalOp7244); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(LT232); }

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1452:10: GT
                    {
                    GT233=(Token)match(input,GT,FOLLOW_GT_in_relationalOp7257); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(GT233); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 84, relationalOp_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "relationalOp"



    // $ANTLR start "shiftExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1455:1: shiftExpression : additiveExpression ( shiftOp additiveExpression )* ;
    public final void shiftExpression() throws RecognitionException {
        int shiftExpression_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 85) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1456:5: ( additiveExpression ( shiftOp additiveExpression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1456:9: additiveExpression ( shiftOp additiveExpression )*
            {
            pushFollow(FOLLOW_additiveExpression_in_shiftExpression7279);
            additiveExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1457:9: ( shiftOp additiveExpression )*
            loop150:
            do {
                int alt150=2;
                int LA150_0 = input.LA(1);

                if ( (LA150_0==LT) ) {
                    int LA150_1 = input.LA(2);

                    if ( (LA150_1==LT) ) {
                        int LA150_4 = input.LA(3);

                        if ( (LA150_4==BANG||LA150_4==BOOLEAN||LA150_4==BYTE||(LA150_4 >= CHAR && LA150_4 <= CHARLITERAL)||(LA150_4 >= DOUBLE && LA150_4 <= DOUBLELITERAL)||LA150_4==FALSE||(LA150_4 >= FLOAT && LA150_4 <= FLOATLITERAL)||LA150_4==IDENTIFIER||LA150_4==INT||LA150_4==INTLITERAL||(LA150_4 >= LONG && LA150_4 <= LPAREN)||(LA150_4 >= NEW && LA150_4 <= NULL)||LA150_4==PLUS||LA150_4==PLUSPLUS||LA150_4==SHORT||(LA150_4 >= STRINGLITERAL && LA150_4 <= SUB)||(LA150_4 >= SUBSUB && LA150_4 <= SUPER)||LA150_4==THIS||LA150_4==TILDE||LA150_4==TRUE||LA150_4==VOID) ) {
                            alt150=1;
                        }


                    }


                }
                else if ( (LA150_0==GT) ) {
                    int LA150_2 = input.LA(2);

                    if ( (LA150_2==GT) ) {
                        int LA150_5 = input.LA(3);

                        if ( (LA150_5==GT) ) {
                            int LA150_7 = input.LA(4);

                            if ( (LA150_7==BANG||LA150_7==BOOLEAN||LA150_7==BYTE||(LA150_7 >= CHAR && LA150_7 <= CHARLITERAL)||(LA150_7 >= DOUBLE && LA150_7 <= DOUBLELITERAL)||LA150_7==FALSE||(LA150_7 >= FLOAT && LA150_7 <= FLOATLITERAL)||LA150_7==IDENTIFIER||LA150_7==INT||LA150_7==INTLITERAL||(LA150_7 >= LONG && LA150_7 <= LPAREN)||(LA150_7 >= NEW && LA150_7 <= NULL)||LA150_7==PLUS||LA150_7==PLUSPLUS||LA150_7==SHORT||(LA150_7 >= STRINGLITERAL && LA150_7 <= SUB)||(LA150_7 >= SUBSUB && LA150_7 <= SUPER)||LA150_7==THIS||LA150_7==TILDE||LA150_7==TRUE||LA150_7==VOID) ) {
                                alt150=1;
                            }


                        }
                        else if ( (LA150_5==BANG||LA150_5==BOOLEAN||LA150_5==BYTE||(LA150_5 >= CHAR && LA150_5 <= CHARLITERAL)||(LA150_5 >= DOUBLE && LA150_5 <= DOUBLELITERAL)||LA150_5==FALSE||(LA150_5 >= FLOAT && LA150_5 <= FLOATLITERAL)||LA150_5==IDENTIFIER||LA150_5==INT||LA150_5==INTLITERAL||(LA150_5 >= LONG && LA150_5 <= LPAREN)||(LA150_5 >= NEW && LA150_5 <= NULL)||LA150_5==PLUS||LA150_5==PLUSPLUS||LA150_5==SHORT||(LA150_5 >= STRINGLITERAL && LA150_5 <= SUB)||(LA150_5 >= SUBSUB && LA150_5 <= SUPER)||LA150_5==THIS||LA150_5==TILDE||LA150_5==TRUE||LA150_5==VOID) ) {
                            alt150=1;
                        }


                    }


                }


                switch (alt150) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1457:10: shiftOp additiveExpression
            	    {
            	    pushFollow(FOLLOW_shiftOp_in_shiftExpression7290);
            	    shiftOp();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    pushFollow(FOLLOW_additiveExpression_in_shiftExpression7292);
            	    additiveExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop150;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 85, shiftExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "shiftExpression"



    // $ANTLR start "shiftOp"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1462:1: shiftOp : (a= LT b= LT |a= GT '>' b= GT |a= GT b= GT );
    public final void shiftOp() throws RecognitionException {
        int shiftOp_StartIndex = input.index();

        Token a=null;
        Token b=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 86) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1463:5: (a= LT b= LT |a= GT '>' b= GT |a= GT b= GT )
            int alt151=3;
            int LA151_0 = input.LA(1);

            if ( (LA151_0==LT) ) {
                alt151=1;
            }
            else if ( (LA151_0==GT) ) {
                int LA151_2 = input.LA(2);

                if ( (LA151_2==GT) ) {
                    int LA151_3 = input.LA(3);

                    if ( (LA151_3==GT) ) {
                        alt151=2;
                    }
                    else if ( (LA151_3==BANG||LA151_3==BOOLEAN||LA151_3==BYTE||(LA151_3 >= CHAR && LA151_3 <= CHARLITERAL)||(LA151_3 >= DOUBLE && LA151_3 <= DOUBLELITERAL)||LA151_3==FALSE||(LA151_3 >= FLOAT && LA151_3 <= FLOATLITERAL)||LA151_3==IDENTIFIER||LA151_3==INT||LA151_3==INTLITERAL||(LA151_3 >= LONG && LA151_3 <= LPAREN)||(LA151_3 >= NEW && LA151_3 <= NULL)||LA151_3==PLUS||LA151_3==PLUSPLUS||LA151_3==SHORT||(LA151_3 >= STRINGLITERAL && LA151_3 <= SUB)||(LA151_3 >= SUBSUB && LA151_3 <= SUPER)||LA151_3==THIS||LA151_3==TILDE||LA151_3==TRUE||LA151_3==VOID) ) {
                        alt151=3;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 151, 3, input);

                        throw nvae;

                    }
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 151, 2, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 151, 0, input);

                throw nvae;

            }
            switch (alt151) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1463:10: a= LT b= LT
                    {
                    a=(Token)match(input,LT,FOLLOW_LT_in_shiftOp7327); if (state.failed) return ;

                    b=(Token)match(input,LT,FOLLOW_LT_in_shiftOp7331); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(a, Key.LSHIFT); usa(b, Key.LSHIFT); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1464:10: a= GT '>' b= GT
                    {
                    a=(Token)match(input,GT,FOLLOW_GT_in_shiftOp7346); if (state.failed) return ;

                    match(input,GT,FOLLOW_GT_in_shiftOp7348); if (state.failed) return ;

                    b=(Token)match(input,GT,FOLLOW_GT_in_shiftOp7352); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(a, Key.URSHIFT); usa(b, Key.URSHIFT); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1465:10: a= GT b= GT
                    {
                    a=(Token)match(input,GT,FOLLOW_GT_in_shiftOp7367); if (state.failed) return ;

                    b=(Token)match(input,GT,FOLLOW_GT_in_shiftOp7371); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(a, Key.RSHIFT); usa(b, Key.RSHIFT); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 86, shiftOp_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "shiftOp"



    // $ANTLR start "additiveExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1469:1: additiveExpression : multiplicativeExpression ( ( PLUS | SUB ) multiplicativeExpression )* ;
    public final void additiveExpression() throws RecognitionException {
        int additiveExpression_StartIndex = input.index();

        Token PLUS234=null;
        Token SUB235=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 87) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1470:5: ( multiplicativeExpression ( ( PLUS | SUB ) multiplicativeExpression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1470:9: multiplicativeExpression ( ( PLUS | SUB ) multiplicativeExpression )*
            {
            pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression7394);
            multiplicativeExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1471:9: ( ( PLUS | SUB ) multiplicativeExpression )*
            loop153:
            do {
                int alt153=2;
                int LA153_0 = input.LA(1);

                if ( (LA153_0==PLUS||LA153_0==SUB) ) {
                    alt153=1;
                }


                switch (alt153) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1472:13: ( PLUS | SUB ) multiplicativeExpression
            	    {
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1472:13: ( PLUS | SUB )
            	    int alt152=2;
            	    int LA152_0 = input.LA(1);

            	    if ( (LA152_0==PLUS) ) {
            	        alt152=1;
            	    }
            	    else if ( (LA152_0==SUB) ) {
            	        alt152=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 152, 0, input);

            	        throw nvae;

            	    }
            	    switch (alt152) {
            	        case 1 :
            	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1472:17: PLUS
            	            {
            	            PLUS234=(Token)match(input,PLUS,FOLLOW_PLUS_in_additiveExpression7425); if (state.failed) return ;

            	            if ( state.backtracking==0 ) { usc(PLUS234); }

            	            }
            	            break;
            	        case 2 :
            	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1473:17: SUB
            	            {
            	            SUB235=(Token)match(input,SUB,FOLLOW_SUB_in_additiveExpression7445); if (state.failed) return ;

            	            if ( state.backtracking==0 ) { usc(SUB235); }

            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression7475);
            	    multiplicativeExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop153;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 87, additiveExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "additiveExpression"



    // $ANTLR start "multiplicativeExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1479:1: multiplicativeExpression : unaryExpression ( ( STAR | SLASH | PERCENT ) unaryExpression )* ;
    public final void multiplicativeExpression() throws RecognitionException {
        int multiplicativeExpression_StartIndex = input.index();

        Token STAR236=null;
        Token SLASH237=null;
        Token PERCENT238=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 88) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1480:5: ( unaryExpression ( ( STAR | SLASH | PERCENT ) unaryExpression )* )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1481:9: unaryExpression ( ( STAR | SLASH | PERCENT ) unaryExpression )*
            {
            pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression7513);
            unaryExpression();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1482:9: ( ( STAR | SLASH | PERCENT ) unaryExpression )*
            loop155:
            do {
                int alt155=2;
                int LA155_0 = input.LA(1);

                if ( (LA155_0==PERCENT||LA155_0==SLASH||LA155_0==STAR) ) {
                    alt155=1;
                }


                switch (alt155) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1483:13: ( STAR | SLASH | PERCENT ) unaryExpression
            	    {
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1483:13: ( STAR | SLASH | PERCENT )
            	    int alt154=3;
            	    switch ( input.LA(1) ) {
            	    case STAR:
            	        {
            	        alt154=1;
            	        }
            	        break;
            	    case SLASH:
            	        {
            	        alt154=2;
            	        }
            	        break;
            	    case PERCENT:
            	        {
            	        alt154=3;
            	        }
            	        break;
            	    default:
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 154, 0, input);

            	        throw nvae;

            	    }

            	    switch (alt154) {
            	        case 1 :
            	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1483:17: STAR
            	            {
            	            STAR236=(Token)match(input,STAR,FOLLOW_STAR_in_multiplicativeExpression7544); if (state.failed) return ;

            	            if ( state.backtracking==0 ) { usc(STAR236); }

            	            }
            	            break;
            	        case 2 :
            	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1484:17: SLASH
            	            {
            	            SLASH237=(Token)match(input,SLASH,FOLLOW_SLASH_in_multiplicativeExpression7565); if (state.failed) return ;

            	            if ( state.backtracking==0 ) { usc(SLASH237); }

            	            }
            	            break;
            	        case 3 :
            	            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1485:17: PERCENT
            	            {
            	            PERCENT238=(Token)match(input,PERCENT,FOLLOW_PERCENT_in_multiplicativeExpression7585); if (state.failed) return ;

            	            if ( state.backtracking==0 ) { usc(PERCENT238); }

            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression7615);
            	    unaryExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop155;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 88, multiplicativeExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "multiplicativeExpression"



    // $ANTLR start "unaryExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1495:1: unaryExpression : ( PLUS unaryExpression | SUB unaryExpression | PLUSPLUS unaryExpression | SUBSUB unaryExpression | unaryExpressionNotPlusMinus );
    public final void unaryExpression() throws RecognitionException {
        int unaryExpression_StartIndex = input.index();

        Token PLUS239=null;
        Token SUB240=null;
        Token PLUSPLUS241=null;
        Token SUBSUB242=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 89) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1496:5: ( PLUS unaryExpression | SUB unaryExpression | PLUSPLUS unaryExpression | SUBSUB unaryExpression | unaryExpressionNotPlusMinus )
            int alt156=5;
            switch ( input.LA(1) ) {
            case PLUS:
                {
                alt156=1;
                }
                break;
            case SUB:
                {
                alt156=2;
                }
                break;
            case PLUSPLUS:
                {
                alt156=3;
                }
                break;
            case SUBSUB:
                {
                alt156=4;
                }
                break;
            case BANG:
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CHARLITERAL:
            case DOUBLE:
            case DOUBLELITERAL:
            case FALSE:
            case FLOAT:
            case FLOATLITERAL:
            case IDENTIFIER:
            case INT:
            case INTLITERAL:
            case LONG:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case SHORT:
            case STRINGLITERAL:
            case SUPER:
            case THIS:
            case TILDE:
            case TRUE:
            case VOID:
                {
                alt156=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 156, 0, input);

                throw nvae;

            }

            switch (alt156) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1496:9: PLUS unaryExpression
                    {
                    PLUS239=(Token)match(input,PLUS,FOLLOW_PLUS_in_unaryExpression7648); if (state.failed) return ;

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression7651);
                    unaryExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(PLUS239, Key.PLUS_PREFIX); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1497:9: SUB unaryExpression
                    {
                    SUB240=(Token)match(input,SUB,FOLLOW_SUB_in_unaryExpression7664); if (state.failed) return ;

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression7666);
                    unaryExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(SUB240, Key.SUB_PREFIX); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1498:9: PLUSPLUS unaryExpression
                    {
                    PLUSPLUS241=(Token)match(input,PLUSPLUS,FOLLOW_PLUSPLUS_in_unaryExpression7679); if (state.failed) return ;

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression7681);
                    unaryExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(PLUSPLUS241, Key.PLUSPLUS_PREFIX); }

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1499:9: SUBSUB unaryExpression
                    {
                    SUBSUB242=(Token)match(input,SUBSUB,FOLLOW_SUBSUB_in_unaryExpression7693); if (state.failed) return ;

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression7695);
                    unaryExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(SUBSUB242, Key.SUBSUB_PREFIX); }

                    }
                    break;
                case 5 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1500:9: unaryExpressionNotPlusMinus
                    {
                    pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression7708);
                    unaryExpressionNotPlusMinus();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 89, unaryExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "unaryExpression"



    // $ANTLR start "unaryExpressionNotPlusMinus"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1503:1: unaryExpressionNotPlusMinus : ( TILDE unaryExpression | BANG unaryExpression | castExpression | primary ( selector )* ( PLUSPLUS | SUBSUB )? );
    public final void unaryExpressionNotPlusMinus() throws RecognitionException {
        int unaryExpressionNotPlusMinus_StartIndex = input.index();

        Token TILDE243=null;
        Token BANG244=null;
        Token PLUSPLUS245=null;
        Token SUBSUB246=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 90) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1504:5: ( TILDE unaryExpression | BANG unaryExpression | castExpression | primary ( selector )* ( PLUSPLUS | SUBSUB )? )
            int alt159=4;
            switch ( input.LA(1) ) {
            case TILDE:
                {
                alt159=1;
                }
                break;
            case BANG:
                {
                alt159=2;
                }
                break;
            case LPAREN:
                {
                int LA159_3 = input.LA(2);

                if ( (synpred240_JavaTypo()) ) {
                    alt159=3;
                }
                else if ( (true) ) {
                    alt159=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 159, 3, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CHARLITERAL:
            case DOUBLE:
            case DOUBLELITERAL:
            case FALSE:
            case FLOAT:
            case FLOATLITERAL:
            case IDENTIFIER:
            case INT:
            case INTLITERAL:
            case LONG:
            case LONGLITERAL:
            case NEW:
            case NULL:
            case SHORT:
            case STRINGLITERAL:
            case SUPER:
            case THIS:
            case TRUE:
            case VOID:
                {
                alt159=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 159, 0, input);

                throw nvae;

            }

            switch (alt159) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1504:9: TILDE unaryExpression
                    {
                    TILDE243=(Token)match(input,TILDE,FOLLOW_TILDE_in_unaryExpressionNotPlusMinus7729); if (state.failed) return ;

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus7731);
                    unaryExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(TILDE243); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1505:9: BANG unaryExpression
                    {
                    BANG244=(Token)match(input,BANG,FOLLOW_BANG_in_unaryExpressionNotPlusMinus7743); if (state.failed) return ;

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus7745);
                    unaryExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(BANG244); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1506:9: castExpression
                    {
                    pushFollow(FOLLOW_castExpression_in_unaryExpressionNotPlusMinus7757);
                    castExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1507:9: primary ( selector )* ( PLUSPLUS | SUBSUB )?
                    {
                    pushFollow(FOLLOW_primary_in_unaryExpressionNotPlusMinus7767);
                    primary();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1508:9: ( selector )*
                    loop157:
                    do {
                        int alt157=2;
                        int LA157_0 = input.LA(1);

                        if ( (LA157_0==DOT||LA157_0==LBRACKET) ) {
                            alt157=1;
                        }


                        switch (alt157) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1508:10: selector
                    	    {
                    	    pushFollow(FOLLOW_selector_in_unaryExpressionNotPlusMinus7778);
                    	    selector();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop157;
                        }
                    } while (true);


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1510:9: ( PLUSPLUS | SUBSUB )?
                    int alt158=3;
                    int LA158_0 = input.LA(1);

                    if ( (LA158_0==PLUSPLUS) ) {
                        alt158=1;
                    }
                    else if ( (LA158_0==SUBSUB) ) {
                        alt158=2;
                    }
                    switch (alt158) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1510:13: PLUSPLUS
                            {
                            PLUSPLUS245=(Token)match(input,PLUSPLUS,FOLLOW_PLUSPLUS_in_unaryExpressionNotPlusMinus7803); if (state.failed) return ;

                            if ( state.backtracking==0 ) { usb(PLUSPLUS245, Key.PLUSPLUS_POSTFIX); }

                            }
                            break;
                        case 2 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1511:13: SUBSUB
                            {
                            SUBSUB246=(Token)match(input,SUBSUB,FOLLOW_SUBSUB_in_unaryExpressionNotPlusMinus7819); if (state.failed) return ;

                            if ( state.backtracking==0 ) { usb(SUBSUB246, Key.SUBSUB_POSTFIX); }

                            }
                            break;

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 90, unaryExpressionNotPlusMinus_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "unaryExpressionNotPlusMinus"



    // $ANTLR start "castExpression"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1515:1: castExpression : ( LPAREN primitiveType RPAREN unaryExpression | LPAREN type RPAREN unaryExpressionNotPlusMinus );
    public final void castExpression() throws RecognitionException {
        int castExpression_StartIndex = input.index();

        Token LPAREN247=null;
        Token RPAREN248=null;
        Token LPAREN249=null;
        Token RPAREN250=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 91) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1516:5: ( LPAREN primitiveType RPAREN unaryExpression | LPAREN type RPAREN unaryExpressionNotPlusMinus )
            int alt160=2;
            int LA160_0 = input.LA(1);

            if ( (LA160_0==LPAREN) ) {
                int LA160_1 = input.LA(2);

                if ( (synpred244_JavaTypo()) ) {
                    alt160=1;
                }
                else if ( (true) ) {
                    alt160=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 160, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 160, 0, input);

                throw nvae;

            }
            switch (alt160) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1516:9: LPAREN primitiveType RPAREN unaryExpression
                    {
                    LPAREN247=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_castExpression7852); if (state.failed) return ;

                    pushFollow(FOLLOW_primitiveType_in_castExpression7854);
                    primitiveType();

                    state._fsp--;
                    if (state.failed) return ;

                    RPAREN248=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_castExpression7856); if (state.failed) return ;

                    pushFollow(FOLLOW_unaryExpression_in_castExpression7858);
                    unaryExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(LPAREN247); usb(RPAREN248); usa(RPAREN248, Key.RPAREN_CAST); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1517:9: LPAREN type RPAREN unaryExpressionNotPlusMinus
                    {
                    LPAREN249=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_castExpression7871); if (state.failed) return ;

                    pushFollow(FOLLOW_type_in_castExpression7873);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    RPAREN250=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_castExpression7875); if (state.failed) return ;

                    pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_castExpression7877);
                    unaryExpressionNotPlusMinus();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(LPAREN249); usb(RPAREN250); usa(RPAREN250, Key.RPAREN_CAST); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 91, castExpression_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "castExpression"



    // $ANTLR start "primary"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1523:1: primary : ( parExpression | THIS ( DOT IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( DOT IDENTIFIER )* ( identifierSuffix )? | SUPER superSuffix | literal | creator | primitiveType ( LBRACKET RBRACKET )* DOT 'class' | 'void' DOT 'class' );
    public final void primary() throws RecognitionException {
        int primary_StartIndex = input.index();

        Token DOT251=null;
        Token THIS252=null;
        Token DOT253=null;
        Token SUPER254=null;
        Token LBRACKET255=null;
        Token RBRACKET256=null;
        Token DOT257=null;
        Token DOT258=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 92) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1524:5: ( parExpression | THIS ( DOT IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( DOT IDENTIFIER )* ( identifierSuffix )? | SUPER superSuffix | literal | creator | primitiveType ( LBRACKET RBRACKET )* DOT 'class' | 'void' DOT 'class' )
            int alt166=8;
            switch ( input.LA(1) ) {
            case LPAREN:
                {
                alt166=1;
                }
                break;
            case THIS:
                {
                alt166=2;
                }
                break;
            case IDENTIFIER:
                {
                alt166=3;
                }
                break;
            case SUPER:
                {
                alt166=4;
                }
                break;
            case CHARLITERAL:
            case DOUBLELITERAL:
            case FALSE:
            case FLOATLITERAL:
            case INTLITERAL:
            case LONGLITERAL:
            case NULL:
            case STRINGLITERAL:
            case TRUE:
                {
                alt166=5;
                }
                break;
            case NEW:
                {
                alt166=6;
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
                {
                alt166=7;
                }
                break;
            case VOID:
                {
                alt166=8;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 166, 0, input);

                throw nvae;

            }

            switch (alt166) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1524:9: parExpression
                    {
                    pushFollow(FOLLOW_parExpression_in_primary7902);
                    parExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1525:9: THIS ( DOT IDENTIFIER )* ( identifierSuffix )?
                    {
                    THIS252=(Token)match(input,THIS,FOLLOW_THIS_in_primary7924); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1526:9: ( DOT IDENTIFIER )*
                    loop161:
                    do {
                        int alt161=2;
                        int LA161_0 = input.LA(1);

                        if ( (LA161_0==DOT) ) {
                            int LA161_2 = input.LA(2);

                            if ( (LA161_2==IDENTIFIER) ) {
                                int LA161_3 = input.LA(3);

                                if ( (synpred246_JavaTypo()) ) {
                                    alt161=1;
                                }


                            }


                        }


                        switch (alt161) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1526:10: DOT IDENTIFIER
                    	    {
                    	    DOT251=(Token)match(input,DOT,FOLLOW_DOT_in_primary7935); if (state.failed) return ;

                    	    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary7937); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usc(DOT251); }

                    	    }
                    	    break;

                    	default :
                    	    break loop161;
                        }
                    } while (true);


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1528:9: ( identifierSuffix )?
                    int alt162=2;
                    switch ( input.LA(1) ) {
                        case LBRACKET:
                            {
                            int LA162_1 = input.LA(2);

                            if ( (synpred247_JavaTypo()) ) {
                                alt162=1;
                            }
                            }
                            break;
                        case LPAREN:
                            {
                            alt162=1;
                            }
                            break;
                        case DOT:
                            {
                            int LA162_3 = input.LA(2);

                            if ( (synpred247_JavaTypo()) ) {
                                alt162=1;
                            }
                            }
                            break;
                    }

                    switch (alt162) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1528:10: identifierSuffix
                            {
                            pushFollow(FOLLOW_identifierSuffix_in_primary7961);
                            identifierSuffix();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { usa(THIS252); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1531:9: IDENTIFIER ( DOT IDENTIFIER )* ( identifierSuffix )?
                    {
                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary7992); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1532:9: ( DOT IDENTIFIER )*
                    loop163:
                    do {
                        int alt163=2;
                        int LA163_0 = input.LA(1);

                        if ( (LA163_0==DOT) ) {
                            int LA163_2 = input.LA(2);

                            if ( (LA163_2==IDENTIFIER) ) {
                                int LA163_3 = input.LA(3);

                                if ( (synpred249_JavaTypo()) ) {
                                    alt163=1;
                                }


                            }


                        }


                        switch (alt163) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1532:10: DOT IDENTIFIER
                    	    {
                    	    DOT253=(Token)match(input,DOT,FOLLOW_DOT_in_primary8003); if (state.failed) return ;

                    	    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary8005); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usc(DOT253); }

                    	    }
                    	    break;

                    	default :
                    	    break loop163;
                        }
                    } while (true);


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1534:9: ( identifierSuffix )?
                    int alt164=2;
                    switch ( input.LA(1) ) {
                        case LBRACKET:
                            {
                            int LA164_1 = input.LA(2);

                            if ( (synpred250_JavaTypo()) ) {
                                alt164=1;
                            }
                            }
                            break;
                        case LPAREN:
                            {
                            alt164=1;
                            }
                            break;
                        case DOT:
                            {
                            int LA164_3 = input.LA(2);

                            if ( (synpred250_JavaTypo()) ) {
                                alt164=1;
                            }
                            }
                            break;
                    }

                    switch (alt164) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1534:10: identifierSuffix
                            {
                            pushFollow(FOLLOW_identifierSuffix_in_primary8029);
                            identifierSuffix();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1536:9: SUPER superSuffix
                    {
                    SUPER254=(Token)match(input,SUPER,FOLLOW_SUPER_in_primary8050); if (state.failed) return ;

                    pushFollow(FOLLOW_superSuffix_in_primary8060);
                    superSuffix();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(SUPER254); }

                    }
                    break;
                case 5 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1539:9: literal
                    {
                    pushFollow(FOLLOW_literal_in_primary8080);
                    literal();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 6 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1540:9: creator
                    {
                    pushFollow(FOLLOW_creator_in_primary8090);
                    creator();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 7 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1541:9: primitiveType ( LBRACKET RBRACKET )* DOT 'class'
                    {
                    pushFollow(FOLLOW_primitiveType_in_primary8100);
                    primitiveType();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1542:9: ( LBRACKET RBRACKET )*
                    loop165:
                    do {
                        int alt165=2;
                        int LA165_0 = input.LA(1);

                        if ( (LA165_0==LBRACKET) ) {
                            alt165=1;
                        }


                        switch (alt165) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1542:10: LBRACKET RBRACKET
                    	    {
                    	    LBRACKET255=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_primary8111); if (state.failed) return ;

                    	    RBRACKET256=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_primary8113); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usa(LBRACKET255); usb(RBRACKET256); }

                    	    }
                    	    break;

                    	default :
                    	    break loop165;
                        }
                    } while (true);


                    DOT257=(Token)match(input,DOT,FOLLOW_DOT_in_primary8136); if (state.failed) return ;

                    match(input,CLASS,FOLLOW_CLASS_in_primary8138); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(DOT257); }

                    }
                    break;
                case 8 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1545:9: 'void' DOT 'class'
                    {
                    match(input,VOID,FOLLOW_VOID_in_primary8150); if (state.failed) return ;

                    DOT258=(Token)match(input,DOT,FOLLOW_DOT_in_primary8152); if (state.failed) return ;

                    match(input,CLASS,FOLLOW_CLASS_in_primary8154); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(DOT258); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 92, primary_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "primary"



    // $ANTLR start "superSuffix"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1549:1: superSuffix : ( arguments | DOT ( typeArguments )? IDENTIFIER ( arguments )? );
    public final void superSuffix() throws RecognitionException {
        int superSuffix_StartIndex = input.index();

        Token DOT259=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 93) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1550:5: ( arguments | DOT ( typeArguments )? IDENTIFIER ( arguments )? )
            int alt169=2;
            int LA169_0 = input.LA(1);

            if ( (LA169_0==LPAREN) ) {
                alt169=1;
            }
            else if ( (LA169_0==DOT) ) {
                alt169=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 169, 0, input);

                throw nvae;

            }
            switch (alt169) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1550:9: arguments
                    {
                    pushFollow(FOLLOW_arguments_in_superSuffix8182);
                    arguments();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1551:9: DOT ( typeArguments )? IDENTIFIER ( arguments )?
                    {
                    DOT259=(Token)match(input,DOT,FOLLOW_DOT_in_superSuffix8192); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1551:13: ( typeArguments )?
                    int alt167=2;
                    int LA167_0 = input.LA(1);

                    if ( (LA167_0==LT) ) {
                        alt167=1;
                    }
                    switch (alt167) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1551:14: typeArguments
                            {
                            pushFollow(FOLLOW_typeArguments_in_superSuffix8195);
                            typeArguments();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_superSuffix8216); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1554:9: ( arguments )?
                    int alt168=2;
                    int LA168_0 = input.LA(1);

                    if ( (LA168_0==LPAREN) ) {
                        alt168=1;
                    }
                    switch (alt168) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1554:10: arguments
                            {
                            pushFollow(FOLLOW_arguments_in_superSuffix8227);
                            arguments();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { usc(DOT259); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 93, superSuffix_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "superSuffix"



    // $ANTLR start "identifierSuffix"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1560:1: identifierSuffix : ( ( LBRACKET RBRACKET )+ DOT 'class' | ( LBRACKET expression RBRACKET )+ | arguments | DOT 'class' | DOT nonWildcardTypeArguments IDENTIFIER arguments | DOT 'this' | DOT SUPER arguments | innerCreator );
    public final void identifierSuffix() throws RecognitionException {
        int identifierSuffix_StartIndex = input.index();

        Token LBRACKET260=null;
        Token RBRACKET261=null;
        Token DOT262=null;
        Token LBRACKET263=null;
        Token RBRACKET264=null;
        Token DOT265=null;
        Token DOT266=null;
        Token DOT267=null;
        Token DOT268=null;
        Token SUPER269=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 94) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1561:5: ( ( LBRACKET RBRACKET )+ DOT 'class' | ( LBRACKET expression RBRACKET )+ | arguments | DOT 'class' | DOT nonWildcardTypeArguments IDENTIFIER arguments | DOT 'this' | DOT SUPER arguments | innerCreator )
            int alt172=8;
            switch ( input.LA(1) ) {
            case LBRACKET:
                {
                int LA172_1 = input.LA(2);

                if ( (LA172_1==RBRACKET) ) {
                    alt172=1;
                }
                else if ( (LA172_1==BANG||LA172_1==BOOLEAN||LA172_1==BYTE||(LA172_1 >= CHAR && LA172_1 <= CHARLITERAL)||(LA172_1 >= DOUBLE && LA172_1 <= DOUBLELITERAL)||LA172_1==FALSE||(LA172_1 >= FLOAT && LA172_1 <= FLOATLITERAL)||LA172_1==IDENTIFIER||LA172_1==INT||LA172_1==INTLITERAL||(LA172_1 >= LONG && LA172_1 <= LPAREN)||(LA172_1 >= NEW && LA172_1 <= NULL)||LA172_1==PLUS||LA172_1==PLUSPLUS||LA172_1==SHORT||(LA172_1 >= STRINGLITERAL && LA172_1 <= SUB)||(LA172_1 >= SUBSUB && LA172_1 <= SUPER)||LA172_1==THIS||LA172_1==TILDE||LA172_1==TRUE||LA172_1==VOID) ) {
                    alt172=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 172, 1, input);

                    throw nvae;

                }
                }
                break;
            case LPAREN:
                {
                alt172=3;
                }
                break;
            case DOT:
                {
                switch ( input.LA(2) ) {
                case CLASS:
                    {
                    alt172=4;
                    }
                    break;
                case THIS:
                    {
                    alt172=6;
                    }
                    break;
                case SUPER:
                    {
                    alt172=7;
                    }
                    break;
                case NEW:
                    {
                    alt172=8;
                    }
                    break;
                case LT:
                    {
                    alt172=5;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 172, 3, input);

                    throw nvae;

                }

                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 172, 0, input);

                throw nvae;

            }

            switch (alt172) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1561:9: ( LBRACKET RBRACKET )+ DOT 'class'
                    {
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1561:9: ( LBRACKET RBRACKET )+
                    int cnt170=0;
                    loop170:
                    do {
                        int alt170=2;
                        int LA170_0 = input.LA(1);

                        if ( (LA170_0==LBRACKET) ) {
                            alt170=1;
                        }


                        switch (alt170) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1561:10: LBRACKET RBRACKET
                    	    {
                    	    LBRACKET260=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix8270); if (state.failed) return ;

                    	    RBRACKET261=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix8272); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usa(LBRACKET260); usb(RBRACKET261); }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt170 >= 1 ) break loop170;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(170, input);
                                throw eee;
                        }
                        cnt170++;
                    } while (true);


                    DOT262=(Token)match(input,DOT,FOLLOW_DOT_in_identifierSuffix8295); if (state.failed) return ;

                    match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix8297); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(DOT262); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1565:9: ( LBRACKET expression RBRACKET )+
                    {
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1565:9: ( LBRACKET expression RBRACKET )+
                    int cnt171=0;
                    loop171:
                    do {
                        int alt171=2;
                        int LA171_0 = input.LA(1);

                        if ( (LA171_0==LBRACKET) ) {
                            int LA171_2 = input.LA(2);

                            if ( (synpred262_JavaTypo()) ) {
                                alt171=1;
                            }


                        }


                        switch (alt171) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1565:10: LBRACKET expression RBRACKET
                    	    {
                    	    LBRACKET263=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix8318); if (state.failed) return ;

                    	    pushFollow(FOLLOW_expression_in_identifierSuffix8320);
                    	    expression();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    RBRACKET264=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix8322); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usa(LBRACKET263); usb(RBRACKET264); }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt171 >= 1 ) break loop171;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(171, input);
                                throw eee;
                        }
                        cnt171++;
                    } while (true);


                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1567:9: arguments
                    {
                    pushFollow(FOLLOW_arguments_in_identifierSuffix8346);
                    arguments();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1568:9: DOT 'class'
                    {
                    DOT265=(Token)match(input,DOT,FOLLOW_DOT_in_identifierSuffix8356); if (state.failed) return ;

                    match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix8358); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(DOT265); }

                    }
                    break;
                case 5 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1569:9: DOT nonWildcardTypeArguments IDENTIFIER arguments
                    {
                    DOT266=(Token)match(input,DOT,FOLLOW_DOT_in_identifierSuffix8371); if (state.failed) return ;

                    pushFollow(FOLLOW_nonWildcardTypeArguments_in_identifierSuffix8373);
                    nonWildcardTypeArguments();

                    state._fsp--;
                    if (state.failed) return ;

                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifierSuffix8375); if (state.failed) return ;

                    pushFollow(FOLLOW_arguments_in_identifierSuffix8377);
                    arguments();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(DOT266); }

                    }
                    break;
                case 6 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1570:9: DOT 'this'
                    {
                    DOT267=(Token)match(input,DOT,FOLLOW_DOT_in_identifierSuffix8389); if (state.failed) return ;

                    match(input,THIS,FOLLOW_THIS_in_identifierSuffix8391); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(DOT267); }

                    }
                    break;
                case 7 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1571:9: DOT SUPER arguments
                    {
                    DOT268=(Token)match(input,DOT,FOLLOW_DOT_in_identifierSuffix8404); if (state.failed) return ;

                    SUPER269=(Token)match(input,SUPER,FOLLOW_SUPER_in_identifierSuffix8406); if (state.failed) return ;

                    pushFollow(FOLLOW_arguments_in_identifierSuffix8408);
                    arguments();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(DOT268); usa(SUPER269); }

                    }
                    break;
                case 8 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1572:9: innerCreator
                    {
                    pushFollow(FOLLOW_innerCreator_in_identifierSuffix8421);
                    innerCreator();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 94, identifierSuffix_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "identifierSuffix"



    // $ANTLR start "selector"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1576:1: selector : ( DOT IDENTIFIER ( arguments )? | DOT 'this' | DOT 'super' superSuffix | innerCreator | LBRACKET expression RBRACKET );
    public final void selector() throws RecognitionException {
        int selector_StartIndex = input.index();

        Token DOT270=null;
        Token DOT271=null;
        Token DOT272=null;
        Token LBRACKET273=null;
        Token RBRACKET274=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 95) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1577:5: ( DOT IDENTIFIER ( arguments )? | DOT 'this' | DOT 'super' superSuffix | innerCreator | LBRACKET expression RBRACKET )
            int alt174=5;
            int LA174_0 = input.LA(1);

            if ( (LA174_0==DOT) ) {
                switch ( input.LA(2) ) {
                case IDENTIFIER:
                    {
                    alt174=1;
                    }
                    break;
                case THIS:
                    {
                    alt174=2;
                    }
                    break;
                case SUPER:
                    {
                    alt174=3;
                    }
                    break;
                case NEW:
                    {
                    alt174=4;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 174, 1, input);

                    throw nvae;

                }

            }
            else if ( (LA174_0==LBRACKET) ) {
                alt174=5;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 174, 0, input);

                throw nvae;

            }
            switch (alt174) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1577:9: DOT IDENTIFIER ( arguments )?
                    {
                    DOT270=(Token)match(input,DOT,FOLLOW_DOT_in_selector8443); if (state.failed) return ;

                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_selector8445); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1578:9: ( arguments )?
                    int alt173=2;
                    int LA173_0 = input.LA(1);

                    if ( (LA173_0==LPAREN) ) {
                        alt173=1;
                    }
                    switch (alt173) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1578:10: arguments
                            {
                            pushFollow(FOLLOW_arguments_in_selector8456);
                            arguments();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }


                    if ( state.backtracking==0 ) { usc(DOT270); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1581:9: DOT 'this'
                    {
                    DOT271=(Token)match(input,DOT,FOLLOW_DOT_in_selector8487); if (state.failed) return ;

                    match(input,THIS,FOLLOW_THIS_in_selector8489); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(DOT271); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1582:9: DOT 'super' superSuffix
                    {
                    DOT272=(Token)match(input,DOT,FOLLOW_DOT_in_selector8503); if (state.failed) return ;

                    match(input,SUPER,FOLLOW_SUPER_in_selector8505); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(DOT272); }

                    pushFollow(FOLLOW_superSuffix_in_selector8518);
                    superSuffix();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1584:9: innerCreator
                    {
                    pushFollow(FOLLOW_innerCreator_in_selector8528);
                    innerCreator();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1585:9: LBRACKET expression RBRACKET
                    {
                    LBRACKET273=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_selector8538); if (state.failed) return ;

                    pushFollow(FOLLOW_expression_in_selector8540);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    RBRACKET274=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_selector8542); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(LBRACKET273); usb(RBRACKET274); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 95, selector_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "selector"



    // $ANTLR start "creator"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1588:1: creator : ( NEW nonWildcardTypeArguments classOrInterfaceType classCreatorRest | NEW classOrInterfaceType classCreatorRest | arrayCreator );
    public final void creator() throws RecognitionException {
        int creator_StartIndex = input.index();

        Token NEW275=null;
        Token NEW276=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 96) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1589:5: ( NEW nonWildcardTypeArguments classOrInterfaceType classCreatorRest | NEW classOrInterfaceType classCreatorRest | arrayCreator )
            int alt175=3;
            int LA175_0 = input.LA(1);

            if ( (LA175_0==NEW) ) {
                int LA175_1 = input.LA(2);

                if ( (synpred274_JavaTypo()) ) {
                    alt175=1;
                }
                else if ( (synpred275_JavaTypo()) ) {
                    alt175=2;
                }
                else if ( (true) ) {
                    alt175=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 175, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 175, 0, input);

                throw nvae;

            }
            switch (alt175) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1589:9: NEW nonWildcardTypeArguments classOrInterfaceType classCreatorRest
                    {
                    NEW275=(Token)match(input,NEW,FOLLOW_NEW_in_creator8564); if (state.failed) return ;

                    pushFollow(FOLLOW_nonWildcardTypeArguments_in_creator8566);
                    nonWildcardTypeArguments();

                    state._fsp--;
                    if (state.failed) return ;

                    pushFollow(FOLLOW_classOrInterfaceType_in_creator8568);
                    classOrInterfaceType();

                    state._fsp--;
                    if (state.failed) return ;

                    pushFollow(FOLLOW_classCreatorRest_in_creator8570);
                    classCreatorRest();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(NEW275); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1590:9: NEW classOrInterfaceType classCreatorRest
                    {
                    NEW276=(Token)match(input,NEW,FOLLOW_NEW_in_creator8582); if (state.failed) return ;

                    pushFollow(FOLLOW_classOrInterfaceType_in_creator8584);
                    classOrInterfaceType();

                    state._fsp--;
                    if (state.failed) return ;

                    pushFollow(FOLLOW_classCreatorRest_in_creator8586);
                    classCreatorRest();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(NEW276); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1591:9: arrayCreator
                    {
                    pushFollow(FOLLOW_arrayCreator_in_creator8601);
                    arrayCreator();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 96, creator_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "creator"



    // $ANTLR start "arrayCreator"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1594:1: arrayCreator : ( NEW createdName a= LBRACKET b= RBRACKET (c= LBRACKET d= RBRACKET )* arrayInitializer | NEW createdName e= LBRACKET expression f= RBRACKET (a= LBRACKET expression b= RBRACKET )* (c= LBRACKET d= RBRACKET )* );
    public final void arrayCreator() throws RecognitionException {
        int arrayCreator_StartIndex = input.index();

        Token a=null;
        Token b=null;
        Token c=null;
        Token d=null;
        Token e=null;
        Token f=null;
        Token NEW277=null;
        Token NEW278=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 97) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1595:5: ( NEW createdName a= LBRACKET b= RBRACKET (c= LBRACKET d= RBRACKET )* arrayInitializer | NEW createdName e= LBRACKET expression f= RBRACKET (a= LBRACKET expression b= RBRACKET )* (c= LBRACKET d= RBRACKET )* )
            int alt179=2;
            int LA179_0 = input.LA(1);

            if ( (LA179_0==NEW) ) {
                int LA179_1 = input.LA(2);

                if ( (synpred277_JavaTypo()) ) {
                    alt179=1;
                }
                else if ( (true) ) {
                    alt179=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 179, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 179, 0, input);

                throw nvae;

            }
            switch (alt179) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1595:9: NEW createdName a= LBRACKET b= RBRACKET (c= LBRACKET d= RBRACKET )* arrayInitializer
                    {
                    NEW277=(Token)match(input,NEW,FOLLOW_NEW_in_arrayCreator8621); if (state.failed) return ;

                    pushFollow(FOLLOW_createdName_in_arrayCreator8623);
                    createdName();

                    state._fsp--;
                    if (state.failed) return ;

                    a=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator8635); if (state.failed) return ;

                    b=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator8639); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1597:9: (c= LBRACKET d= RBRACKET )*
                    loop176:
                    do {
                        int alt176=2;
                        int LA176_0 = input.LA(1);

                        if ( (LA176_0==LBRACKET) ) {
                            alt176=1;
                        }


                        switch (alt176) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1597:10: c= LBRACKET d= RBRACKET
                    	    {
                    	    c=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator8652); if (state.failed) return ;

                    	    d=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator8656); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usa(c); usb(d); }

                    	    }
                    	    break;

                    	default :
                    	    break loop176;
                        }
                    } while (true);


                    pushFollow(FOLLOW_arrayInitializer_in_arrayCreator8679);
                    arrayInitializer();

                    state._fsp--;
                    if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(NEW277); usa(a); usb(b); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1601:9: NEW createdName e= LBRACKET expression f= RBRACKET (a= LBRACKET expression b= RBRACKET )* (c= LBRACKET d= RBRACKET )*
                    {
                    NEW278=(Token)match(input,NEW,FOLLOW_NEW_in_arrayCreator8699); if (state.failed) return ;

                    pushFollow(FOLLOW_createdName_in_arrayCreator8701);
                    createdName();

                    state._fsp--;
                    if (state.failed) return ;

                    e=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator8713); if (state.failed) return ;

                    pushFollow(FOLLOW_expression_in_arrayCreator8715);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    f=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator8727); if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1604:9: (a= LBRACKET expression b= RBRACKET )*
                    loop177:
                    do {
                        int alt177=2;
                        int LA177_0 = input.LA(1);

                        if ( (LA177_0==LBRACKET) ) {
                            int LA177_1 = input.LA(2);

                            if ( (synpred278_JavaTypo()) ) {
                                alt177=1;
                            }


                        }


                        switch (alt177) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1604:13: a= LBRACKET expression b= RBRACKET
                    	    {
                    	    a=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator8743); if (state.failed) return ;

                    	    pushFollow(FOLLOW_expression_in_arrayCreator8745);
                    	    expression();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    b=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator8761); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usa(a); usb(b); }

                    	    }
                    	    break;

                    	default :
                    	    break loop177;
                        }
                    } while (true);


                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1608:9: (c= LBRACKET d= RBRACKET )*
                    loop178:
                    do {
                        int alt178=2;
                        int LA178_0 = input.LA(1);

                        if ( (LA178_0==LBRACKET) ) {
                            int LA178_2 = input.LA(2);

                            if ( (LA178_2==RBRACKET) ) {
                                alt178=1;
                            }


                        }


                        switch (alt178) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1608:10: c= LBRACKET d= RBRACKET
                    	    {
                    	    c=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator8799); if (state.failed) return ;

                    	    d=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator8803); if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usa(c); usb(d); }

                    	    }
                    	    break;

                    	default :
                    	    break loop178;
                        }
                    } while (true);


                    if ( state.backtracking==0 ) { usa(NEW278); usa(e); usb(f); }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 97, arrayCreator_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "arrayCreator"



    // $ANTLR start "variableInitializer"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1613:1: variableInitializer : ( arrayInitializer | expression );
    public final void variableInitializer() throws RecognitionException {
        int variableInitializer_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 98) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1614:5: ( arrayInitializer | expression )
            int alt180=2;
            int LA180_0 = input.LA(1);

            if ( (LA180_0==LBRACE) ) {
                alt180=1;
            }
            else if ( (LA180_0==BANG||LA180_0==BOOLEAN||LA180_0==BYTE||(LA180_0 >= CHAR && LA180_0 <= CHARLITERAL)||(LA180_0 >= DOUBLE && LA180_0 <= DOUBLELITERAL)||LA180_0==FALSE||(LA180_0 >= FLOAT && LA180_0 <= FLOATLITERAL)||LA180_0==IDENTIFIER||LA180_0==INT||LA180_0==INTLITERAL||(LA180_0 >= LONG && LA180_0 <= LPAREN)||(LA180_0 >= NEW && LA180_0 <= NULL)||LA180_0==PLUS||LA180_0==PLUSPLUS||LA180_0==SHORT||(LA180_0 >= STRINGLITERAL && LA180_0 <= SUB)||(LA180_0 >= SUBSUB && LA180_0 <= SUPER)||LA180_0==THIS||LA180_0==TILDE||LA180_0==TRUE||LA180_0==VOID) ) {
                alt180=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 180, 0, input);

                throw nvae;

            }
            switch (alt180) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1614:9: arrayInitializer
                    {
                    pushFollow(FOLLOW_arrayInitializer_in_variableInitializer8846);
                    arrayInitializer();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1615:9: expression
                    {
                    pushFollow(FOLLOW_expression_in_variableInitializer8856);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 98, variableInitializer_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "variableInitializer"



    // $ANTLR start "arrayInitializer"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1618:1: arrayInitializer : '{' ( variableInitializer (a= COMMA variableInitializer )* )? (b= COMMA )? '}' ;
    public final void arrayInitializer() throws RecognitionException {
        int arrayInitializer_StartIndex = input.index();

        Token a=null;
        Token b=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 99) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1619:5: ( '{' ( variableInitializer (a= COMMA variableInitializer )* )? (b= COMMA )? '}' )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1619:9: '{' ( variableInitializer (a= COMMA variableInitializer )* )? (b= COMMA )? '}'
            {
            match(input,LBRACE,FOLLOW_LBRACE_in_arrayInitializer8876); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1620:13: ( variableInitializer (a= COMMA variableInitializer )* )?
            int alt182=2;
            int LA182_0 = input.LA(1);

            if ( (LA182_0==BANG||LA182_0==BOOLEAN||LA182_0==BYTE||(LA182_0 >= CHAR && LA182_0 <= CHARLITERAL)||(LA182_0 >= DOUBLE && LA182_0 <= DOUBLELITERAL)||LA182_0==FALSE||(LA182_0 >= FLOAT && LA182_0 <= FLOATLITERAL)||LA182_0==IDENTIFIER||LA182_0==INT||LA182_0==INTLITERAL||LA182_0==LBRACE||(LA182_0 >= LONG && LA182_0 <= LPAREN)||(LA182_0 >= NEW && LA182_0 <= NULL)||LA182_0==PLUS||LA182_0==PLUSPLUS||LA182_0==SHORT||(LA182_0 >= STRINGLITERAL && LA182_0 <= SUB)||(LA182_0 >= SUBSUB && LA182_0 <= SUPER)||LA182_0==THIS||LA182_0==TILDE||LA182_0==TRUE||LA182_0==VOID) ) {
                alt182=1;
            }
            switch (alt182) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1620:14: variableInitializer (a= COMMA variableInitializer )*
                    {
                    pushFollow(FOLLOW_variableInitializer_in_arrayInitializer8892);
                    variableInitializer();

                    state._fsp--;
                    if (state.failed) return ;

                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1621:17: (a= COMMA variableInitializer )*
                    loop181:
                    do {
                        int alt181=2;
                        int LA181_0 = input.LA(1);

                        if ( (LA181_0==COMMA) ) {
                            int LA181_1 = input.LA(2);

                            if ( (LA181_1==BANG||LA181_1==BOOLEAN||LA181_1==BYTE||(LA181_1 >= CHAR && LA181_1 <= CHARLITERAL)||(LA181_1 >= DOUBLE && LA181_1 <= DOUBLELITERAL)||LA181_1==FALSE||(LA181_1 >= FLOAT && LA181_1 <= FLOATLITERAL)||LA181_1==IDENTIFIER||LA181_1==INT||LA181_1==INTLITERAL||LA181_1==LBRACE||(LA181_1 >= LONG && LA181_1 <= LPAREN)||(LA181_1 >= NEW && LA181_1 <= NULL)||LA181_1==PLUS||LA181_1==PLUSPLUS||LA181_1==SHORT||(LA181_1 >= STRINGLITERAL && LA181_1 <= SUB)||(LA181_1 >= SUBSUB && LA181_1 <= SUPER)||LA181_1==THIS||LA181_1==TILDE||LA181_1==TRUE||LA181_1==VOID) ) {
                                alt181=1;
                            }


                        }


                        switch (alt181) {
                    	case 1 :
                    	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1621:18: a= COMMA variableInitializer
                    	    {
                    	    a=(Token)match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer8913); if (state.failed) return ;

                    	    pushFollow(FOLLOW_variableInitializer_in_arrayInitializer8915);
                    	    variableInitializer();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    if ( state.backtracking==0 ) { usc(a); }

                    	    }
                    	    break;

                    	default :
                    	    break loop181;
                        }
                    } while (true);


                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1624:13: (b= COMMA )?
            int alt183=2;
            int LA183_0 = input.LA(1);

            if ( (LA183_0==COMMA) ) {
                alt183=1;
            }
            switch (alt183) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1624:14: b= COMMA
                    {
                    b=(Token)match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer8969); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(b); }

                    }
                    break;

            }


            match(input,RBRACE,FOLLOW_RBRACE_in_arrayInitializer8985); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 99, arrayInitializer_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "arrayInitializer"



    // $ANTLR start "createdName"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1629:1: createdName : ( classOrInterfaceType | primitiveType );
    public final void createdName() throws RecognitionException {
        int createdName_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 100) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1630:5: ( classOrInterfaceType | primitiveType )
            int alt184=2;
            int LA184_0 = input.LA(1);

            if ( (LA184_0==IDENTIFIER) ) {
                alt184=1;
            }
            else if ( (LA184_0==BOOLEAN||LA184_0==BYTE||LA184_0==CHAR||LA184_0==DOUBLE||LA184_0==FLOAT||LA184_0==INT||LA184_0==LONG||LA184_0==SHORT) ) {
                alt184=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 184, 0, input);

                throw nvae;

            }
            switch (alt184) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1630:9: classOrInterfaceType
                    {
                    pushFollow(FOLLOW_classOrInterfaceType_in_createdName9019);
                    classOrInterfaceType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1631:9: primitiveType
                    {
                    pushFollow(FOLLOW_primitiveType_in_createdName9029);
                    primitiveType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 100, createdName_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "createdName"



    // $ANTLR start "innerCreator"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1634:1: innerCreator : DOT NEW ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest ;
    public final void innerCreator() throws RecognitionException {
        int innerCreator_StartIndex = input.index();

        Token DOT279=null;
        Token NEW280=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 101) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1635:5: ( DOT NEW ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1635:9: DOT NEW ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest
            {
            DOT279=(Token)match(input,DOT,FOLLOW_DOT_in_innerCreator9050); if (state.failed) return ;

            NEW280=(Token)match(input,NEW,FOLLOW_NEW_in_innerCreator9052); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1636:9: ( nonWildcardTypeArguments )?
            int alt185=2;
            int LA185_0 = input.LA(1);

            if ( (LA185_0==LT) ) {
                alt185=1;
            }
            switch (alt185) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1636:10: nonWildcardTypeArguments
                    {
                    pushFollow(FOLLOW_nonWildcardTypeArguments_in_innerCreator9063);
                    nonWildcardTypeArguments();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_innerCreator9084); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1639:9: ( typeArguments )?
            int alt186=2;
            int LA186_0 = input.LA(1);

            if ( (LA186_0==LT) ) {
                alt186=1;
            }
            switch (alt186) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1639:10: typeArguments
                    {
                    pushFollow(FOLLOW_typeArguments_in_innerCreator9095);
                    typeArguments();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            pushFollow(FOLLOW_classCreatorRest_in_innerCreator9116);
            classCreatorRest();

            state._fsp--;
            if (state.failed) return ;

            if ( state.backtracking==0 ) { usc(DOT279); usa(NEW280); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 101, innerCreator_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "innerCreator"



    // $ANTLR start "classCreatorRest"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1646:1: classCreatorRest : arguments ( classBody )? ;
    public final void classCreatorRest() throws RecognitionException {
        int classCreatorRest_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 102) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1647:5: ( arguments ( classBody )? )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1647:9: arguments ( classBody )?
            {
            pushFollow(FOLLOW_arguments_in_classCreatorRest9147);
            arguments();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1648:9: ( classBody )?
            int alt187=2;
            int LA187_0 = input.LA(1);

            if ( (LA187_0==LBRACE) ) {
                alt187=1;
            }
            switch (alt187) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1648:10: classBody
                    {
                    pushFollow(FOLLOW_classBody_in_classCreatorRest9158);
                    classBody();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 102, classCreatorRest_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "classCreatorRest"



    // $ANTLR start "nonWildcardTypeArguments"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1653:1: nonWildcardTypeArguments : LT typeList GT ;
    public final void nonWildcardTypeArguments() throws RecognitionException {
        int nonWildcardTypeArguments_StartIndex = input.index();

        Token LT281=null;
        Token GT282=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 103) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1654:5: ( LT typeList GT )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1654:9: LT typeList GT
            {
            LT281=(Token)match(input,LT,FOLLOW_LT_in_nonWildcardTypeArguments9190); if (state.failed) return ;

            pushFollow(FOLLOW_typeList_in_nonWildcardTypeArguments9192);
            typeList();

            state._fsp--;
            if (state.failed) return ;

            GT282=(Token)match(input,GT,FOLLOW_GT_in_nonWildcardTypeArguments9202); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(LT281, Key.LTYPE); usb(GT282, Key.RTYPE); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 103, nonWildcardTypeArguments_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "nonWildcardTypeArguments"



    // $ANTLR start "arguments"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1659:1: arguments : LPAREN ( expressionList )? RPAREN ;
    public final void arguments() throws RecognitionException {
        int arguments_StartIndex = input.index();

        Token LPAREN283=null;
        Token RPAREN284=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 104) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1660:5: ( LPAREN ( expressionList )? RPAREN )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1660:9: LPAREN ( expressionList )? RPAREN
            {
            LPAREN283=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_arguments9232); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1660:16: ( expressionList )?
            int alt188=2;
            int LA188_0 = input.LA(1);

            if ( (LA188_0==BANG||LA188_0==BOOLEAN||LA188_0==BYTE||(LA188_0 >= CHAR && LA188_0 <= CHARLITERAL)||(LA188_0 >= DOUBLE && LA188_0 <= DOUBLELITERAL)||LA188_0==FALSE||(LA188_0 >= FLOAT && LA188_0 <= FLOATLITERAL)||LA188_0==IDENTIFIER||LA188_0==INT||LA188_0==INTLITERAL||(LA188_0 >= LONG && LA188_0 <= LPAREN)||(LA188_0 >= NEW && LA188_0 <= NULL)||LA188_0==PLUS||LA188_0==PLUSPLUS||LA188_0==SHORT||(LA188_0 >= STRINGLITERAL && LA188_0 <= SUB)||(LA188_0 >= SUBSUB && LA188_0 <= SUPER)||LA188_0==THIS||LA188_0==TILDE||LA188_0==TRUE||LA188_0==VOID) ) {
                alt188=1;
            }
            switch (alt188) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1660:17: expressionList
                    {
                    pushFollow(FOLLOW_expressionList_in_arguments9235);
                    expressionList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            RPAREN284=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_arguments9248); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(LPAREN283); usb(RPAREN284); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 104, arguments_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "arguments"



    // $ANTLR start "literal"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1665:1: literal : ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL );
    public final void literal() throws RecognitionException {
        int literal_StartIndex = input.index();

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 105) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1666:5: ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:
            {
            if ( input.LA(1)==CHARLITERAL||input.LA(1)==DOUBLELITERAL||input.LA(1)==FALSE||input.LA(1)==FLOATLITERAL||input.LA(1)==INTLITERAL||input.LA(1)==LONGLITERAL||input.LA(1)==NULL||input.LA(1)==STRINGLITERAL||input.LA(1)==TRUE ) {
                input.consume();
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 105, literal_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "literal"



    // $ANTLR start "classHeader"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1681:1: classHeader : modifiers CLASS IDENTIFIER ;
    public final void classHeader() throws RecognitionException {
        int classHeader_StartIndex = input.index();

        Token CLASS285=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 106) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1682:5: ( modifiers CLASS IDENTIFIER )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1682:9: modifiers CLASS IDENTIFIER
            {
            pushFollow(FOLLOW_modifiers_in_classHeader9382);
            modifiers();

            state._fsp--;
            if (state.failed) return ;

            CLASS285=(Token)match(input,CLASS,FOLLOW_CLASS_in_classHeader9384); if (state.failed) return ;

            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classHeader9386); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(CLASS285); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 106, classHeader_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "classHeader"



    // $ANTLR start "enumHeader"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1685:1: enumHeader : modifiers ( ENUM | IDENTIFIER ) IDENTIFIER ;
    public final void enumHeader() throws RecognitionException {
        int enumHeader_StartIndex = input.index();

        Token ENUM286=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 107) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1686:5: ( modifiers ( ENUM | IDENTIFIER ) IDENTIFIER )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1686:9: modifiers ( ENUM | IDENTIFIER ) IDENTIFIER
            {
            pushFollow(FOLLOW_modifiers_in_enumHeader9408);
            modifiers();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1686:19: ( ENUM | IDENTIFIER )
            int alt189=2;
            int LA189_0 = input.LA(1);

            if ( (LA189_0==ENUM) ) {
                alt189=1;
            }
            else if ( (LA189_0==IDENTIFIER) ) {
                alt189=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 189, 0, input);

                throw nvae;

            }
            switch (alt189) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1686:20: ENUM
                    {
                    ENUM286=(Token)match(input,ENUM,FOLLOW_ENUM_in_enumHeader9411); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(ENUM286); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1686:42: IDENTIFIER
                    {
                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumHeader9416); if (state.failed) return ;

                    }
                    break;

            }


            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumHeader9419); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 107, enumHeader_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "enumHeader"



    // $ANTLR start "interfaceHeader"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1689:1: interfaceHeader : modifiers INTERFACE IDENTIFIER ;
    public final void interfaceHeader() throws RecognitionException {
        int interfaceHeader_StartIndex = input.index();

        Token INTERFACE287=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 108) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1690:5: ( modifiers INTERFACE IDENTIFIER )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1690:9: modifiers INTERFACE IDENTIFIER
            {
            pushFollow(FOLLOW_modifiers_in_interfaceHeader9440);
            modifiers();

            state._fsp--;
            if (state.failed) return ;

            INTERFACE287=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_interfaceHeader9442); if (state.failed) return ;

            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceHeader9444); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(INTERFACE287); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 108, interfaceHeader_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "interfaceHeader"



    // $ANTLR start "annotationHeader"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1693:1: annotationHeader : modifiers MONKEYS_AT INTERFACE IDENTIFIER ;
    public final void annotationHeader() throws RecognitionException {
        int annotationHeader_StartIndex = input.index();

        Token MONKEYS_AT288=null;
        Token INTERFACE289=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 109) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1694:5: ( modifiers MONKEYS_AT INTERFACE IDENTIFIER )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1694:9: modifiers MONKEYS_AT INTERFACE IDENTIFIER
            {
            pushFollow(FOLLOW_modifiers_in_annotationHeader9466);
            modifiers();

            state._fsp--;
            if (state.failed) return ;

            MONKEYS_AT288=(Token)match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationHeader9468); if (state.failed) return ;

            INTERFACE289=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationHeader9470); if (state.failed) return ;

            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationHeader9472); if (state.failed) return ;

            if ( state.backtracking==0 ) { usc(MONKEYS_AT288); usa(INTERFACE289); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 109, annotationHeader_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "annotationHeader"



    // $ANTLR start "typeHeader"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1697:1: typeHeader : modifiers ( CLASS | ENUM | ( ( MONKEYS_AT )? INTERFACE ) ) IDENTIFIER ;
    public final void typeHeader() throws RecognitionException {
        int typeHeader_StartIndex = input.index();

        Token CLASS290=null;
        Token ENUM291=null;
        Token MONKEYS_AT292=null;
        Token INTERFACE293=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 110) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1698:5: ( modifiers ( CLASS | ENUM | ( ( MONKEYS_AT )? INTERFACE ) ) IDENTIFIER )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1698:9: modifiers ( CLASS | ENUM | ( ( MONKEYS_AT )? INTERFACE ) ) IDENTIFIER
            {
            pushFollow(FOLLOW_modifiers_in_typeHeader9494);
            modifiers();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1698:19: ( CLASS | ENUM | ( ( MONKEYS_AT )? INTERFACE ) )
            int alt191=3;
            switch ( input.LA(1) ) {
            case CLASS:
                {
                alt191=1;
                }
                break;
            case ENUM:
                {
                alt191=2;
                }
                break;
            case INTERFACE:
            case MONKEYS_AT:
                {
                alt191=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 191, 0, input);

                throw nvae;

            }

            switch (alt191) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1698:20: CLASS
                    {
                    CLASS290=(Token)match(input,CLASS,FOLLOW_CLASS_in_typeHeader9497); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(CLASS290); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1698:44: ENUM
                    {
                    ENUM291=(Token)match(input,ENUM,FOLLOW_ENUM_in_typeHeader9502); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(ENUM291); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1698:65: ( ( MONKEYS_AT )? INTERFACE )
                    {
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1698:65: ( ( MONKEYS_AT )? INTERFACE )
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1698:66: ( MONKEYS_AT )? INTERFACE
                    {
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1698:66: ( MONKEYS_AT )?
                    int alt190=2;
                    int LA190_0 = input.LA(1);

                    if ( (LA190_0==MONKEYS_AT) ) {
                        alt190=1;
                    }
                    switch (alt190) {
                        case 1 :
                            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1698:67: MONKEYS_AT
                            {
                            MONKEYS_AT292=(Token)match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_typeHeader9508); if (state.failed) return ;

                            if ( state.backtracking==0 ) { usc(MONKEYS_AT292); }

                            }
                            break;

                    }


                    INTERFACE293=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_typeHeader9515); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(INTERFACE293); }

                    }


                    }
                    break;

            }


            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeHeader9521); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 110, typeHeader_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "typeHeader"



    // $ANTLR start "methodHeader"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1701:1: methodHeader : modifiers ( typeParameters )? ( type | VOID )? IDENTIFIER LPAREN ;
    public final void methodHeader() throws RecognitionException {
        int methodHeader_StartIndex = input.index();

        Token VOID294=null;
        Token LPAREN295=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 111) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1702:5: ( modifiers ( typeParameters )? ( type | VOID )? IDENTIFIER LPAREN )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1702:9: modifiers ( typeParameters )? ( type | VOID )? IDENTIFIER LPAREN
            {
            pushFollow(FOLLOW_modifiers_in_methodHeader9541);
            modifiers();

            state._fsp--;
            if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1702:19: ( typeParameters )?
            int alt192=2;
            int LA192_0 = input.LA(1);

            if ( (LA192_0==LT) ) {
                alt192=1;
            }
            switch (alt192) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1702:19: typeParameters
                    {
                    pushFollow(FOLLOW_typeParameters_in_methodHeader9543);
                    typeParameters();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1702:35: ( type | VOID )?
            int alt193=3;
            switch ( input.LA(1) ) {
                case IDENTIFIER:
                    {
                    int LA193_1 = input.LA(2);

                    if ( (LA193_1==DOT||LA193_1==IDENTIFIER||LA193_1==LBRACKET||LA193_1==LT) ) {
                        alt193=1;
                    }
                    }
                    break;
                case BOOLEAN:
                case BYTE:
                case CHAR:
                case DOUBLE:
                case FLOAT:
                case INT:
                case LONG:
                case SHORT:
                    {
                    alt193=1;
                    }
                    break;
                case VOID:
                    {
                    alt193=2;
                    }
                    break;
            }

            switch (alt193) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1702:36: type
                    {
                    pushFollow(FOLLOW_type_in_methodHeader9547);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1702:41: VOID
                    {
                    VOID294=(Token)match(input,VOID,FOLLOW_VOID_in_methodHeader9549); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usa(VOID294); }

                    }
                    break;

            }


            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodHeader9556); if (state.failed) return ;

            LPAREN295=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_methodHeader9558); if (state.failed) return ;

            if ( state.backtracking==0 ) { usa(LPAREN295); usb(LPAREN295, Key.LPAREN_METHOD); }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 111, methodHeader_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "methodHeader"



    // $ANTLR start "fieldHeader"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1705:1: fieldHeader : modifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ | COMMA | SEMI ) ;
    public final void fieldHeader() throws RecognitionException {
        int fieldHeader_StartIndex = input.index();

        Token LBRACKET296=null;
        Token RBRACKET297=null;
        Token EQ298=null;
        Token COMMA299=null;
        Token SEMI300=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 112) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1706:5: ( modifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ | COMMA | SEMI ) )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1706:9: modifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ | COMMA | SEMI )
            {
            pushFollow(FOLLOW_modifiers_in_fieldHeader9580);
            modifiers();

            state._fsp--;
            if (state.failed) return ;

            pushFollow(FOLLOW_type_in_fieldHeader9582);
            type();

            state._fsp--;
            if (state.failed) return ;

            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_fieldHeader9584); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1706:35: ( LBRACKET RBRACKET )*
            loop194:
            do {
                int alt194=2;
                int LA194_0 = input.LA(1);

                if ( (LA194_0==LBRACKET) ) {
                    alt194=1;
                }


                switch (alt194) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1706:36: LBRACKET RBRACKET
            	    {
            	    LBRACKET296=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_fieldHeader9587); if (state.failed) return ;

            	    RBRACKET297=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_fieldHeader9589); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(LBRACKET296); usb(RBRACKET297); }

            	    }
            	    break;

            	default :
            	    break loop194;
                }
            } while (true);


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1706:92: ( EQ | COMMA | SEMI )
            int alt195=3;
            switch ( input.LA(1) ) {
            case EQ:
                {
                alt195=1;
                }
                break;
            case COMMA:
                {
                alt195=2;
                }
                break;
            case SEMI:
                {
                alt195=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 195, 0, input);

                throw nvae;

            }

            switch (alt195) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1706:93: EQ
                    {
                    EQ298=(Token)match(input,EQ,FOLLOW_EQ_in_fieldHeader9596); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(EQ298); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1706:111: COMMA
                    {
                    COMMA299=(Token)match(input,COMMA,FOLLOW_COMMA_in_fieldHeader9601); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(COMMA299); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1706:135: SEMI
                    {
                    SEMI300=(Token)match(input,SEMI,FOLLOW_SEMI_in_fieldHeader9606); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(SEMI300); addStmt((SEMI300!=null?SEMI300.getLine():0)); }

                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 112, fieldHeader_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "fieldHeader"



    // $ANTLR start "localVariableHeader"
    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1709:1: localVariableHeader : variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ | COMMA | SEMI ) ;
    public final void localVariableHeader() throws RecognitionException {
        int localVariableHeader_StartIndex = input.index();

        Token LBRACKET301=null;
        Token RBRACKET302=null;
        Token EQ303=null;
        Token COMMA304=null;
        Token SEMI305=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 113) ) { return ; }

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1710:5: ( variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ | COMMA | SEMI ) )
            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1710:9: variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ | COMMA | SEMI )
            {
            pushFollow(FOLLOW_variableModifiers_in_localVariableHeader9629);
            variableModifiers();

            state._fsp--;
            if (state.failed) return ;

            pushFollow(FOLLOW_type_in_localVariableHeader9631);
            type();

            state._fsp--;
            if (state.failed) return ;

            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_localVariableHeader9633); if (state.failed) return ;

            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1710:43: ( LBRACKET RBRACKET )*
            loop196:
            do {
                int alt196=2;
                int LA196_0 = input.LA(1);

                if ( (LA196_0==LBRACKET) ) {
                    alt196=1;
                }


                switch (alt196) {
            	case 1 :
            	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1710:44: LBRACKET RBRACKET
            	    {
            	    LBRACKET301=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_localVariableHeader9636); if (state.failed) return ;

            	    RBRACKET302=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_localVariableHeader9638); if (state.failed) return ;

            	    if ( state.backtracking==0 ) { usa(LBRACKET301); usb(RBRACKET302); }

            	    }
            	    break;

            	default :
            	    break loop196;
                }
            } while (true);


            // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1710:100: ( EQ | COMMA | SEMI )
            int alt197=3;
            switch ( input.LA(1) ) {
            case EQ:
                {
                alt197=1;
                }
                break;
            case COMMA:
                {
                alt197=2;
                }
                break;
            case SEMI:
                {
                alt197=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 197, 0, input);

                throw nvae;

            }

            switch (alt197) {
                case 1 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1710:101: EQ
                    {
                    EQ303=(Token)match(input,EQ,FOLLOW_EQ_in_localVariableHeader9645); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(EQ303); }

                    }
                    break;
                case 2 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1710:119: COMMA
                    {
                    COMMA304=(Token)match(input,COMMA,FOLLOW_COMMA_in_localVariableHeader9650); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usc(COMMA304); }

                    }
                    break;
                case 3 :
                    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1710:143: SEMI
                    {
                    SEMI305=(Token)match(input,SEMI,FOLLOW_SEMI_in_localVariableHeader9655); if (state.failed) return ;

                    if ( state.backtracking==0 ) { usb(SEMI305); addStmt((SEMI305!=null?SEMI305.getLine():0)); }

                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 113, localVariableHeader_StartIndex); }

        }
        return ;
    }
    // $ANTLR end "localVariableHeader"

    // $ANTLR start synpred2_JavaTypo
    public final void synpred2_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:10: ( ( annotations )? packageDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:10: ( annotations )? packageDeclaration
        {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:10: ( annotations )?
        int alt198=2;
        int LA198_0 = input.LA(1);

        if ( (LA198_0==MONKEYS_AT) ) {
            alt198=1;
        }
        switch (alt198) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:599:11: annotations
                {
                pushFollow(FOLLOW_annotations_in_synpred2_JavaTypo116);
                annotations();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        pushFollow(FOLLOW_packageDeclaration_in_synpred2_JavaTypo120);
        packageDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred2_JavaTypo

    // $ANTLR start synpred12_JavaTypo
    public final void synpred12_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:655:10: ( classDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:655:10: classDeclaration
        {
        pushFollow(FOLLOW_classDeclaration_in_synpred12_JavaTypo484);
        classDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred12_JavaTypo

    // $ANTLR start synpred38_JavaTypo
    public final void synpred38_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:705:9: ( normalClassDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:705:9: normalClassDeclaration
        {
        pushFollow(FOLLOW_normalClassDeclaration_in_synpred38_JavaTypo910);
        normalClassDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred38_JavaTypo

    // $ANTLR start synpred56_JavaTypo
    public final void synpred56_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:802:9: ( normalInterfaceDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:802:9: normalInterfaceDeclaration
        {
        pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred56_JavaTypo1668);
        normalInterfaceDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred56_JavaTypo

    // $ANTLR start synpred66_JavaTypo
    public final void synpred66_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:848:10: ( fieldDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:848:10: fieldDeclaration
        {
        pushFollow(FOLLOW_fieldDeclaration_in_synpred66_JavaTypo2045);
        fieldDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred66_JavaTypo

    // $ANTLR start synpred67_JavaTypo
    public final void synpred67_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:849:10: ( methodDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:849:10: methodDeclaration
        {
        pushFollow(FOLLOW_methodDeclaration_in_synpred67_JavaTypo2058);
        methodDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred67_JavaTypo

    // $ANTLR start synpred68_JavaTypo
    public final void synpred68_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:850:10: ( classDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:850:10: classDeclaration
        {
        pushFollow(FOLLOW_classDeclaration_in_synpred68_JavaTypo2071);
        classDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred68_JavaTypo

    // $ANTLR start synpred72_JavaTypo
    public final void synpred72_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:866:10: ( explicitConstructorInvocation )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:866:10: explicitConstructorInvocation
        {
        pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred72_JavaTypo2218);
        explicitConstructorInvocation();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred72_JavaTypo

    // $ANTLR start synpred74_JavaTypo
    public final void synpred74_JavaTypo_fragment() throws RecognitionException {
        Token a=null;
        Token b=null;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:858:9: ( ( annotations )? mods ( typeParameters )? IDENTIFIER formalParameters ( THROWS qualifiedNameList )? a= '{' ( explicitConstructorInvocation )? ( blockStatement )* b= '}' )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:858:9: ( annotations )? mods ( typeParameters )? IDENTIFIER formalParameters ( THROWS qualifiedNameList )? a= '{' ( explicitConstructorInvocation )? ( blockStatement )* b= '}'
        {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:858:9: ( annotations )?
        int alt200=2;
        int LA200_0 = input.LA(1);

        if ( (LA200_0==MONKEYS_AT) ) {
            alt200=1;
        }
        switch (alt200) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:858:9: annotations
                {
                pushFollow(FOLLOW_annotations_in_synpred74_JavaTypo2123);
                annotations();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        pushFollow(FOLLOW_mods_in_synpred74_JavaTypo2126);
        mods();

        state._fsp--;
        if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:859:9: ( typeParameters )?
        int alt201=2;
        int LA201_0 = input.LA(1);

        if ( (LA201_0==LT) ) {
            alt201=1;
        }
        switch (alt201) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:859:10: typeParameters
                {
                pushFollow(FOLLOW_typeParameters_in_synpred74_JavaTypo2137);
                typeParameters();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred74_JavaTypo2158); if (state.failed) return ;

        pushFollow(FOLLOW_formalParameters_in_synpred74_JavaTypo2168);
        formalParameters();

        state._fsp--;
        if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:863:9: ( THROWS qualifiedNameList )?
        int alt202=2;
        int LA202_0 = input.LA(1);

        if ( (LA202_0==THROWS) ) {
            alt202=1;
        }
        switch (alt202) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:863:10: THROWS qualifiedNameList
                {
                match(input,THROWS,FOLLOW_THROWS_in_synpred74_JavaTypo2179); if (state.failed) return ;

                pushFollow(FOLLOW_qualifiedNameList_in_synpred74_JavaTypo2181);
                qualifiedNameList();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        a=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_synpred74_JavaTypo2206); if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:866:9: ( explicitConstructorInvocation )?
        int alt203=2;
        switch ( input.LA(1) ) {
            case LT:
                {
                alt203=1;
                }
                break;
            case THIS:
                {
                int LA203_2 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case SUPER:
                {
                int LA203_3 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case LPAREN:
                {
                int LA203_4 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case IDENTIFIER:
                {
                int LA203_5 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case CHARLITERAL:
            case DOUBLELITERAL:
            case FALSE:
            case FLOATLITERAL:
            case INTLITERAL:
            case LONGLITERAL:
            case NULL:
            case STRINGLITERAL:
            case TRUE:
                {
                int LA203_6 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case NEW:
                {
                int LA203_7 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case BOOLEAN:
                {
                int LA203_8 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case CHAR:
                {
                int LA203_9 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case BYTE:
                {
                int LA203_10 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case SHORT:
                {
                int LA203_11 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case INT:
                {
                int LA203_12 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case LONG:
                {
                int LA203_13 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case FLOAT:
                {
                int LA203_14 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case DOUBLE:
                {
                int LA203_15 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
            case VOID:
                {
                int LA203_16 = input.LA(2);

                if ( (synpred72_JavaTypo()) ) {
                    alt203=1;
                }
                }
                break;
        }

        switch (alt203) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:866:10: explicitConstructorInvocation
                {
                pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred74_JavaTypo2218);
                explicitConstructorInvocation();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:868:9: ( blockStatement )*
        loop204:
        do {
            int alt204=2;
            int LA204_0 = input.LA(1);

            if ( (LA204_0==ABSTRACT||(LA204_0 >= ASSERT && LA204_0 <= BANG)||(LA204_0 >= BOOLEAN && LA204_0 <= BYTE)||(LA204_0 >= CHAR && LA204_0 <= CLASS)||LA204_0==CONTINUE||LA204_0==DO||(LA204_0 >= DOUBLE && LA204_0 <= DOUBLELITERAL)||LA204_0==ENUM||(LA204_0 >= FALSE && LA204_0 <= FINAL)||(LA204_0 >= FLOAT && LA204_0 <= FOR)||(LA204_0 >= IDENTIFIER && LA204_0 <= IF)||(LA204_0 >= INT && LA204_0 <= INTLITERAL)||LA204_0==LBRACE||(LA204_0 >= LONG && LA204_0 <= LT)||(LA204_0 >= MONKEYS_AT && LA204_0 <= NULL)||LA204_0==PLUS||(LA204_0 >= PLUSPLUS && LA204_0 <= PUBLIC)||LA204_0==RETURN||(LA204_0 >= SEMI && LA204_0 <= SHORT)||(LA204_0 >= STATIC && LA204_0 <= SUB)||(LA204_0 >= SUBSUB && LA204_0 <= SYNCHRONIZED)||(LA204_0 >= THIS && LA204_0 <= THROW)||(LA204_0 >= TILDE && LA204_0 <= WHILE)) ) {
                alt204=1;
            }


            switch (alt204) {
        	case 1 :
        	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:868:10: blockStatement
        	    {
        	    pushFollow(FOLLOW_blockStatement_in_synpred74_JavaTypo2240);
        	    blockStatement();

        	    state._fsp--;
        	    if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop204;
            }
        } while (true);


        b=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_synpred74_JavaTypo2263); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred74_JavaTypo

    // $ANTLR start synpred84_JavaTypo
    public final void synpred84_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:924:9: ( interfaceFieldDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:924:9: interfaceFieldDeclaration
        {
        pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred84_JavaTypo2689);
        interfaceFieldDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred84_JavaTypo

    // $ANTLR start synpred85_JavaTypo
    public final void synpred85_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:925:9: ( interfaceMethodDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:925:9: interfaceMethodDeclaration
        {
        pushFollow(FOLLOW_interfaceMethodDeclaration_in_synpred85_JavaTypo2699);
        interfaceMethodDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred85_JavaTypo

    // $ANTLR start synpred86_JavaTypo
    public final void synpred86_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:926:9: ( interfaceDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:926:9: interfaceDeclaration
        {
        pushFollow(FOLLOW_interfaceDeclaration_in_synpred86_JavaTypo2709);
        interfaceDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred86_JavaTypo

    // $ANTLR start synpred87_JavaTypo
    public final void synpred87_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:927:9: ( classDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:927:9: classDeclaration
        {
        pushFollow(FOLLOW_classDeclaration_in_synpred87_JavaTypo2719);
        classDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred87_JavaTypo

    // $ANTLR start synpred114_JavaTypo
    public final void synpred114_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1026:9: ( ellipsisParameterDecl )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1026:9: ellipsisParameterDecl
        {
        pushFollow(FOLLOW_ellipsisParameterDecl_in_synpred114_JavaTypo3606);
        ellipsisParameterDecl();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred114_JavaTypo

    // $ANTLR start synpred116_JavaTypo
    public final void synpred116_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1027:9: ( normalParameterDecl ( COMMA normalParameterDecl )* )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1027:9: normalParameterDecl ( COMMA normalParameterDecl )*
        {
        pushFollow(FOLLOW_normalParameterDecl_in_synpred116_JavaTypo3616);
        normalParameterDecl();

        state._fsp--;
        if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1028:9: ( COMMA normalParameterDecl )*
        loop207:
        do {
            int alt207=2;
            int LA207_0 = input.LA(1);

            if ( (LA207_0==COMMA) ) {
                alt207=1;
            }


            switch (alt207) {
        	case 1 :
        	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1028:10: COMMA normalParameterDecl
        	    {
        	    match(input,COMMA,FOLLOW_COMMA_in_synpred116_JavaTypo3627); if (state.failed) return ;

        	    pushFollow(FOLLOW_normalParameterDecl_in_synpred116_JavaTypo3629);
        	    normalParameterDecl();

        	    state._fsp--;
        	    if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop207;
            }
        } while (true);


        }

    }
    // $ANTLR end synpred116_JavaTypo

    // $ANTLR start synpred117_JavaTypo
    public final void synpred117_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1030:10: ( normalParameterDecl COMMA )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1030:10: normalParameterDecl COMMA
        {
        pushFollow(FOLLOW_normalParameterDecl_in_synpred117_JavaTypo3653);
        normalParameterDecl();

        state._fsp--;
        if (state.failed) return ;

        match(input,COMMA,FOLLOW_COMMA_in_synpred117_JavaTypo3663); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred117_JavaTypo

    // $ANTLR start synpred121_JavaTypo
    public final void synpred121_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1051:9: ( ( nonWildcardTypeArguments )? ( THIS | SUPER ) arguments SEMI )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1051:9: ( nonWildcardTypeArguments )? ( THIS | SUPER ) arguments SEMI
        {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1051:9: ( nonWildcardTypeArguments )?
        int alt208=2;
        int LA208_0 = input.LA(1);

        if ( (LA208_0==LT) ) {
            alt208=1;
        }
        switch (alt208) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1051:10: nonWildcardTypeArguments
                {
                pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred121_JavaTypo3813);
                nonWildcardTypeArguments();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        if ( input.LA(1)==SUPER||input.LA(1)==THIS ) {
            input.consume();
            state.errorRecovery=false;
            state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            throw mse;
        }


        pushFollow(FOLLOW_arguments_in_synpred121_JavaTypo3877);
        arguments();

        state._fsp--;
        if (state.failed) return ;

        match(input,SEMI,FOLLOW_SEMI_in_synpred121_JavaTypo3879); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred121_JavaTypo

    // $ANTLR start synpred136_JavaTypo
    public final void synpred136_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1145:9: ( annotationMethodDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1145:9: annotationMethodDeclaration
        {
        pushFollow(FOLLOW_annotationMethodDeclaration_in_synpred136_JavaTypo4572);
        annotationMethodDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred136_JavaTypo

    // $ANTLR start synpred137_JavaTypo
    public final void synpred137_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1146:9: ( interfaceFieldDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1146:9: interfaceFieldDeclaration
        {
        pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred137_JavaTypo4582);
        interfaceFieldDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred137_JavaTypo

    // $ANTLR start synpred138_JavaTypo
    public final void synpred138_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1147:9: ( normalClassDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1147:9: normalClassDeclaration
        {
        pushFollow(FOLLOW_normalClassDeclaration_in_synpred138_JavaTypo4592);
        normalClassDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred138_JavaTypo

    // $ANTLR start synpred139_JavaTypo
    public final void synpred139_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1148:9: ( normalInterfaceDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1148:9: normalInterfaceDeclaration
        {
        pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred139_JavaTypo4602);
        normalInterfaceDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred139_JavaTypo

    // $ANTLR start synpred140_JavaTypo
    public final void synpred140_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1149:9: ( enumDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1149:9: enumDeclaration
        {
        pushFollow(FOLLOW_enumDeclaration_in_synpred140_JavaTypo4612);
        enumDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred140_JavaTypo

    // $ANTLR start synpred141_JavaTypo
    public final void synpred141_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1150:9: ( annotationTypeDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1150:9: annotationTypeDeclaration
        {
        pushFollow(FOLLOW_annotationTypeDeclaration_in_synpred141_JavaTypo4622);
        annotationTypeDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred141_JavaTypo

    // $ANTLR start synpred144_JavaTypo
    public final void synpred144_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1209:9: ( localVariableDeclarationStatement )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1209:9: localVariableDeclarationStatement
        {
        pushFollow(FOLLOW_localVariableDeclarationStatement_in_synpred144_JavaTypo4811);
        localVariableDeclarationStatement();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred144_JavaTypo

    // $ANTLR start synpred145_JavaTypo
    public final void synpred145_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1210:9: ( classOrInterfaceDeclaration )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1210:9: classOrInterfaceDeclaration
        {
        pushFollow(FOLLOW_classOrInterfaceDeclaration_in_synpred145_JavaTypo4821);
        classOrInterfaceDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred145_JavaTypo

    // $ANTLR start synpred149_JavaTypo
    public final void synpred149_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1230:9: ( ( ASSERT ) expression ( COLON expression )? SEMI )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1230:9: ( ASSERT ) expression ( COLON expression )? SEMI
        {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1230:9: ( ASSERT )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1230:10: ASSERT
        {
        match(input,ASSERT,FOLLOW_ASSERT_in_synpred149_JavaTypo4974); if (state.failed) return ;

        }


        pushFollow(FOLLOW_expression_in_synpred149_JavaTypo4994);
        expression();

        state._fsp--;
        if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1232:20: ( COLON expression )?
        int alt211=2;
        int LA211_0 = input.LA(1);

        if ( (LA211_0==COLON) ) {
            alt211=1;
        }
        switch (alt211) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1232:21: COLON expression
                {
                match(input,COLON,FOLLOW_COLON_in_synpred149_JavaTypo4997); if (state.failed) return ;

                pushFollow(FOLLOW_expression_in_synpred149_JavaTypo4999);
                expression();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        match(input,SEMI,FOLLOW_SEMI_in_synpred149_JavaTypo5005); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred149_JavaTypo

    // $ANTLR start synpred151_JavaTypo
    public final void synpred151_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1234:9: ( ASSERT expression ( COLON expression )? SEMI )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1234:9: ASSERT expression ( COLON expression )? SEMI
        {
        match(input,ASSERT,FOLLOW_ASSERT_in_synpred151_JavaTypo5033); if (state.failed) return ;

        pushFollow(FOLLOW_expression_in_synpred151_JavaTypo5036);
        expression();

        state._fsp--;
        if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1234:28: ( COLON expression )?
        int alt212=2;
        int LA212_0 = input.LA(1);

        if ( (LA212_0==COLON) ) {
            alt212=1;
        }
        switch (alt212) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1234:29: COLON expression
                {
                match(input,COLON,FOLLOW_COLON_in_synpred151_JavaTypo5039); if (state.failed) return ;

                pushFollow(FOLLOW_expression_in_synpred151_JavaTypo5041);
                expression();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        match(input,SEMI,FOLLOW_SEMI_in_synpred151_JavaTypo5047); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred151_JavaTypo

    // $ANTLR start synpred152_JavaTypo
    public final void synpred152_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1236:21: ( block )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1236:21: block
        {
        pushFollow(FOLLOW_block_in_synpred152_JavaTypo5079);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred152_JavaTypo

    // $ANTLR start synpred153_JavaTypo
    public final void synpred153_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:34: ( block )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:34: block
        {
        pushFollow(FOLLOW_block_in_synpred153_JavaTypo5106);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred153_JavaTypo

    // $ANTLR start synpred154_JavaTypo
    public final void synpred154_JavaTypo_fragment() throws RecognitionException {
        Token c=null;
        Token b=null;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:7: (c= ELSE b= IF parExpression ( block | statement ) )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:7: c= ELSE b= IF parExpression ( block | statement )
        {
        c=(Token)match(input,ELSE,FOLLOW_ELSE_in_synpred154_JavaTypo5095); if (state.failed) return ;

        b=(Token)match(input,IF,FOLLOW_IF_in_synpred154_JavaTypo5099); if (state.failed) return ;

        pushFollow(FOLLOW_parExpression_in_synpred154_JavaTypo5101);
        parExpression();

        state._fsp--;
        if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:33: ( block | statement )
        int alt213=2;
        int LA213_0 = input.LA(1);

        if ( (LA213_0==LBRACE) ) {
            int LA213_1 = input.LA(2);

            if ( (synpred153_JavaTypo()) ) {
                alt213=1;
            }
            else if ( (true) ) {
                alt213=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 213, 1, input);

                throw nvae;

            }
        }
        else if ( ((LA213_0 >= ASSERT && LA213_0 <= BANG)||(LA213_0 >= BOOLEAN && LA213_0 <= BYTE)||(LA213_0 >= CHAR && LA213_0 <= CHARLITERAL)||LA213_0==CONTINUE||LA213_0==DO||(LA213_0 >= DOUBLE && LA213_0 <= DOUBLELITERAL)||LA213_0==FALSE||(LA213_0 >= FLOAT && LA213_0 <= FOR)||(LA213_0 >= IDENTIFIER && LA213_0 <= IF)||LA213_0==INT||LA213_0==INTLITERAL||(LA213_0 >= LONG && LA213_0 <= LPAREN)||(LA213_0 >= NEW && LA213_0 <= NULL)||LA213_0==PLUS||LA213_0==PLUSPLUS||LA213_0==RETURN||(LA213_0 >= SEMI && LA213_0 <= SHORT)||(LA213_0 >= STRINGLITERAL && LA213_0 <= SUB)||(LA213_0 >= SUBSUB && LA213_0 <= SYNCHRONIZED)||(LA213_0 >= THIS && LA213_0 <= THROW)||LA213_0==TILDE||(LA213_0 >= TRUE && LA213_0 <= VOID)||LA213_0==WHILE) ) {
            alt213=2;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            NoViableAltException nvae =
                new NoViableAltException("", 213, 0, input);

            throw nvae;

        }
        switch (alt213) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:34: block
                {
                pushFollow(FOLLOW_block_in_synpred154_JavaTypo5106);
                block();

                state._fsp--;
                if (state.failed) return ;

                }
                break;
            case 2 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1237:67: statement
                {
                pushFollow(FOLLOW_statement_in_synpred154_JavaTypo5110);
                statement();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        }

    }
    // $ANTLR end synpred154_JavaTypo

    // $ANTLR start synpred155_JavaTypo
    public final void synpred155_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:15: ( block )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:15: block
        {
        pushFollow(FOLLOW_block_in_synpred155_JavaTypo5136);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred155_JavaTypo

    // $ANTLR start synpred156_JavaTypo
    public final void synpred156_JavaTypo_fragment() throws RecognitionException {
        Token d=null;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:7: (d= ELSE ( block | statement ) )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:7: d= ELSE ( block | statement )
        {
        d=(Token)match(input,ELSE,FOLLOW_ELSE_in_synpred156_JavaTypo5131); if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:14: ( block | statement )
        int alt214=2;
        int LA214_0 = input.LA(1);

        if ( (LA214_0==LBRACE) ) {
            int LA214_1 = input.LA(2);

            if ( (synpred155_JavaTypo()) ) {
                alt214=1;
            }
            else if ( (true) ) {
                alt214=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 214, 1, input);

                throw nvae;

            }
        }
        else if ( ((LA214_0 >= ASSERT && LA214_0 <= BANG)||(LA214_0 >= BOOLEAN && LA214_0 <= BYTE)||(LA214_0 >= CHAR && LA214_0 <= CHARLITERAL)||LA214_0==CONTINUE||LA214_0==DO||(LA214_0 >= DOUBLE && LA214_0 <= DOUBLELITERAL)||LA214_0==FALSE||(LA214_0 >= FLOAT && LA214_0 <= FOR)||(LA214_0 >= IDENTIFIER && LA214_0 <= IF)||LA214_0==INT||LA214_0==INTLITERAL||(LA214_0 >= LONG && LA214_0 <= LPAREN)||(LA214_0 >= NEW && LA214_0 <= NULL)||LA214_0==PLUS||LA214_0==PLUSPLUS||LA214_0==RETURN||(LA214_0 >= SEMI && LA214_0 <= SHORT)||(LA214_0 >= STRINGLITERAL && LA214_0 <= SUB)||(LA214_0 >= SUBSUB && LA214_0 <= SYNCHRONIZED)||(LA214_0 >= THIS && LA214_0 <= THROW)||LA214_0==TILDE||(LA214_0 >= TRUE && LA214_0 <= VOID)||LA214_0==WHILE) ) {
            alt214=2;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            NoViableAltException nvae =
                new NoViableAltException("", 214, 0, input);

            throw nvae;

        }
        switch (alt214) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:15: block
                {
                pushFollow(FOLLOW_block_in_synpred156_JavaTypo5136);
                block();

                state._fsp--;
                if (state.failed) return ;

                }
                break;
            case 2 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1238:48: statement
                {
                pushFollow(FOLLOW_statement_in_synpred156_JavaTypo5140);
                statement();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        }

    }
    // $ANTLR end synpred156_JavaTypo

    // $ANTLR start synpred159_JavaTypo
    public final void synpred159_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1241:30: ( block )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1241:30: block
        {
        pushFollow(FOLLOW_block_in_synpred159_JavaTypo5181);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred159_JavaTypo

    // $ANTLR start synpred161_JavaTypo
    public final void synpred161_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1242:13: ( block )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1242:13: block
        {
        pushFollow(FOLLOW_block_in_synpred161_JavaTypo5203);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred161_JavaTypo

    // $ANTLR start synpred173_JavaTypo
    public final void synpred173_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1256:9: ( expression SEMI )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1256:9: expression SEMI
        {
        pushFollow(FOLLOW_expression_in_synpred173_JavaTypo5412);
        expression();

        state._fsp--;
        if (state.failed) return ;

        match(input,SEMI,FOLLOW_SEMI_in_synpred173_JavaTypo5415); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred173_JavaTypo

    // $ANTLR start synpred174_JavaTypo
    public final void synpred174_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1257:9: ( IDENTIFIER COLON statement )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1257:9: IDENTIFIER COLON statement
        {
        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred174_JavaTypo5427); if (state.failed) return ;

        match(input,COLON,FOLLOW_COLON_in_synpred174_JavaTypo5429); if (state.failed) return ;

        pushFollow(FOLLOW_statement_in_synpred174_JavaTypo5431);
        statement();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred174_JavaTypo

    // $ANTLR start synpred178_JavaTypo
    public final void synpred178_JavaTypo_fragment() throws RecognitionException {
        Token a=null;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1280:13: ( catches a= FINALLY block )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1280:13: catches a= FINALLY block
        {
        pushFollow(FOLLOW_catches_in_synpred178_JavaTypo5599);
        catches();

        state._fsp--;
        if (state.failed) return ;

        a=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_synpred178_JavaTypo5603); if (state.failed) return ;

        pushFollow(FOLLOW_block_in_synpred178_JavaTypo5607);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred178_JavaTypo

    // $ANTLR start synpred179_JavaTypo
    public final void synpred179_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1281:13: ( catches )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1281:13: catches
        {
        pushFollow(FOLLOW_catches_in_synpred179_JavaTypo5623);
        catches();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred179_JavaTypo

    // $ANTLR start synpred181_JavaTypo
    public final void synpred181_JavaTypo_fragment() throws RecognitionException {
        Token c=null;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1286:9: ( catches c= FINALLY block )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1286:9: catches c= FINALLY block
        {
        pushFollow(FOLLOW_catches_in_synpred181_JavaTypo5693);
        catches();

        state._fsp--;
        if (state.failed) return ;

        c=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_synpred181_JavaTypo5697); if (state.failed) return ;

        pushFollow(FOLLOW_block_in_synpred181_JavaTypo5701);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred181_JavaTypo

    // $ANTLR start synpred182_JavaTypo
    public final void synpred182_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1287:13: ( catches )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1287:13: catches
        {
        pushFollow(FOLLOW_catches_in_synpred182_JavaTypo5717);
        catches();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred182_JavaTypo

    // $ANTLR start synpred190_JavaTypo
    public final void synpred190_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1329:28: ( block )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1329:28: block
        {
        pushFollow(FOLLOW_block_in_synpred190_JavaTypo6077);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred190_JavaTypo

    // $ANTLR start synpred191_JavaTypo
    public final void synpred191_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1328:9: ( FOR LPAREN variableModifiers type IDENTIFIER COLON expression RPAREN ( block | statement ) )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1328:9: FOR LPAREN variableModifiers type IDENTIFIER COLON expression RPAREN ( block | statement )
        {
        match(input,FOR,FOLLOW_FOR_in_synpred191_JavaTypo6048); if (state.failed) return ;

        match(input,LPAREN,FOLLOW_LPAREN_in_synpred191_JavaTypo6050); if (state.failed) return ;

        pushFollow(FOLLOW_variableModifiers_in_synpred191_JavaTypo6052);
        variableModifiers();

        state._fsp--;
        if (state.failed) return ;

        pushFollow(FOLLOW_type_in_synpred191_JavaTypo6054);
        type();

        state._fsp--;
        if (state.failed) return ;

        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred191_JavaTypo6056); if (state.failed) return ;

        match(input,COLON,FOLLOW_COLON_in_synpred191_JavaTypo6058); if (state.failed) return ;

        pushFollow(FOLLOW_expression_in_synpred191_JavaTypo6069);
        expression();

        state._fsp--;
        if (state.failed) return ;

        match(input,RPAREN,FOLLOW_RPAREN_in_synpred191_JavaTypo6071); if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1329:27: ( block | statement )
        int alt226=2;
        int LA226_0 = input.LA(1);

        if ( (LA226_0==LBRACE) ) {
            int LA226_1 = input.LA(2);

            if ( (synpred190_JavaTypo()) ) {
                alt226=1;
            }
            else if ( (true) ) {
                alt226=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 226, 1, input);

                throw nvae;

            }
        }
        else if ( ((LA226_0 >= ASSERT && LA226_0 <= BANG)||(LA226_0 >= BOOLEAN && LA226_0 <= BYTE)||(LA226_0 >= CHAR && LA226_0 <= CHARLITERAL)||LA226_0==CONTINUE||LA226_0==DO||(LA226_0 >= DOUBLE && LA226_0 <= DOUBLELITERAL)||LA226_0==FALSE||(LA226_0 >= FLOAT && LA226_0 <= FOR)||(LA226_0 >= IDENTIFIER && LA226_0 <= IF)||LA226_0==INT||LA226_0==INTLITERAL||(LA226_0 >= LONG && LA226_0 <= LPAREN)||(LA226_0 >= NEW && LA226_0 <= NULL)||LA226_0==PLUS||LA226_0==PLUSPLUS||LA226_0==RETURN||(LA226_0 >= SEMI && LA226_0 <= SHORT)||(LA226_0 >= STRINGLITERAL && LA226_0 <= SUB)||(LA226_0 >= SUBSUB && LA226_0 <= SYNCHRONIZED)||(LA226_0 >= THIS && LA226_0 <= THROW)||LA226_0==TILDE||(LA226_0 >= TRUE && LA226_0 <= VOID)||LA226_0==WHILE) ) {
            alt226=2;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            NoViableAltException nvae =
                new NoViableAltException("", 226, 0, input);

            throw nvae;

        }
        switch (alt226) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1329:28: block
                {
                pushFollow(FOLLOW_block_in_synpred191_JavaTypo6077);
                block();

                state._fsp--;
                if (state.failed) return ;

                }
                break;
            case 2 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1329:65: statement
                {
                pushFollow(FOLLOW_statement_in_synpred191_JavaTypo6081);
                statement();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        }

    }
    // $ANTLR end synpred191_JavaTypo

    // $ANTLR start synpred195_JavaTypo
    public final void synpred195_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1338:28: ( block )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1338:28: block
        {
        pushFollow(FOLLOW_block_in_synpred195_JavaTypo6248);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred195_JavaTypo

    // $ANTLR start synpred199_JavaTypo
    public final void synpred199_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1343:9: ( variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ variableInitializer )? ( COMMA variableDeclarator )* )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1343:9: variableModifiers type IDENTIFIER ( LBRACKET RBRACKET )* ( EQ variableInitializer )? ( COMMA variableDeclarator )*
        {
        pushFollow(FOLLOW_variableModifiers_in_synpred199_JavaTypo6283);
        variableModifiers();

        state._fsp--;
        if (state.failed) return ;

        pushFollow(FOLLOW_type_in_synpred199_JavaTypo6285);
        type();

        state._fsp--;
        if (state.failed) return ;

        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred199_JavaTypo6295); if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1345:9: ( LBRACKET RBRACKET )*
        loop227:
        do {
            int alt227=2;
            int LA227_0 = input.LA(1);

            if ( (LA227_0==LBRACKET) ) {
                alt227=1;
            }


            switch (alt227) {
        	case 1 :
        	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1345:10: LBRACKET RBRACKET
        	    {
        	    match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred199_JavaTypo6306); if (state.failed) return ;

        	    match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred199_JavaTypo6308); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop227;
            }
        } while (true);


        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1347:9: ( EQ variableInitializer )?
        int alt228=2;
        int LA228_0 = input.LA(1);

        if ( (LA228_0==EQ) ) {
            alt228=1;
        }
        switch (alt228) {
            case 1 :
                // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1347:10: EQ variableInitializer
                {
                match(input,EQ,FOLLOW_EQ_in_synpred199_JavaTypo6332); if (state.failed) return ;

                pushFollow(FOLLOW_variableInitializer_in_synpred199_JavaTypo6334);
                variableInitializer();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1349:9: ( COMMA variableDeclarator )*
        loop229:
        do {
            int alt229=2;
            int LA229_0 = input.LA(1);

            if ( (LA229_0==COMMA) ) {
                alt229=1;
            }


            switch (alt229) {
        	case 1 :
        	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1349:10: COMMA variableDeclarator
        	    {
        	    match(input,COMMA,FOLLOW_COMMA_in_synpred199_JavaTypo6358); if (state.failed) return ;

        	    pushFollow(FOLLOW_variableDeclarator_in_synpred199_JavaTypo6360);
        	    variableDeclarator();

        	    state._fsp--;
        	    if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop229;
            }
        } while (true);


        }

    }
    // $ANTLR end synpred199_JavaTypo

    // $ANTLR start synpred240_JavaTypo
    public final void synpred240_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1506:9: ( castExpression )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1506:9: castExpression
        {
        pushFollow(FOLLOW_castExpression_in_synpred240_JavaTypo7757);
        castExpression();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred240_JavaTypo

    // $ANTLR start synpred244_JavaTypo
    public final void synpred244_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1516:9: ( LPAREN primitiveType RPAREN unaryExpression )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1516:9: LPAREN primitiveType RPAREN unaryExpression
        {
        match(input,LPAREN,FOLLOW_LPAREN_in_synpred244_JavaTypo7852); if (state.failed) return ;

        pushFollow(FOLLOW_primitiveType_in_synpred244_JavaTypo7854);
        primitiveType();

        state._fsp--;
        if (state.failed) return ;

        match(input,RPAREN,FOLLOW_RPAREN_in_synpred244_JavaTypo7856); if (state.failed) return ;

        pushFollow(FOLLOW_unaryExpression_in_synpred244_JavaTypo7858);
        unaryExpression();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred244_JavaTypo

    // $ANTLR start synpred246_JavaTypo
    public final void synpred246_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1526:10: ( DOT IDENTIFIER )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1526:10: DOT IDENTIFIER
        {
        match(input,DOT,FOLLOW_DOT_in_synpred246_JavaTypo7935); if (state.failed) return ;

        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred246_JavaTypo7937); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred246_JavaTypo

    // $ANTLR start synpred247_JavaTypo
    public final void synpred247_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1528:10: ( identifierSuffix )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1528:10: identifierSuffix
        {
        pushFollow(FOLLOW_identifierSuffix_in_synpred247_JavaTypo7961);
        identifierSuffix();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred247_JavaTypo

    // $ANTLR start synpred249_JavaTypo
    public final void synpred249_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1532:10: ( DOT IDENTIFIER )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1532:10: DOT IDENTIFIER
        {
        match(input,DOT,FOLLOW_DOT_in_synpred249_JavaTypo8003); if (state.failed) return ;

        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred249_JavaTypo8005); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred249_JavaTypo

    // $ANTLR start synpred250_JavaTypo
    public final void synpred250_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1534:10: ( identifierSuffix )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1534:10: identifierSuffix
        {
        pushFollow(FOLLOW_identifierSuffix_in_synpred250_JavaTypo8029);
        identifierSuffix();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred250_JavaTypo

    // $ANTLR start synpred262_JavaTypo
    public final void synpred262_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1565:10: ( LBRACKET expression RBRACKET )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1565:10: LBRACKET expression RBRACKET
        {
        match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred262_JavaTypo8318); if (state.failed) return ;

        pushFollow(FOLLOW_expression_in_synpred262_JavaTypo8320);
        expression();

        state._fsp--;
        if (state.failed) return ;

        match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred262_JavaTypo8322); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred262_JavaTypo

    // $ANTLR start synpred274_JavaTypo
    public final void synpred274_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1589:9: ( NEW nonWildcardTypeArguments classOrInterfaceType classCreatorRest )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1589:9: NEW nonWildcardTypeArguments classOrInterfaceType classCreatorRest
        {
        match(input,NEW,FOLLOW_NEW_in_synpred274_JavaTypo8564); if (state.failed) return ;

        pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred274_JavaTypo8566);
        nonWildcardTypeArguments();

        state._fsp--;
        if (state.failed) return ;

        pushFollow(FOLLOW_classOrInterfaceType_in_synpred274_JavaTypo8568);
        classOrInterfaceType();

        state._fsp--;
        if (state.failed) return ;

        pushFollow(FOLLOW_classCreatorRest_in_synpred274_JavaTypo8570);
        classCreatorRest();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred274_JavaTypo

    // $ANTLR start synpred275_JavaTypo
    public final void synpred275_JavaTypo_fragment() throws RecognitionException {
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1590:9: ( NEW classOrInterfaceType classCreatorRest )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1590:9: NEW classOrInterfaceType classCreatorRest
        {
        match(input,NEW,FOLLOW_NEW_in_synpred275_JavaTypo8582); if (state.failed) return ;

        pushFollow(FOLLOW_classOrInterfaceType_in_synpred275_JavaTypo8584);
        classOrInterfaceType();

        state._fsp--;
        if (state.failed) return ;

        pushFollow(FOLLOW_classCreatorRest_in_synpred275_JavaTypo8586);
        classCreatorRest();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred275_JavaTypo

    // $ANTLR start synpred277_JavaTypo
    public final void synpred277_JavaTypo_fragment() throws RecognitionException {
        Token a=null;
        Token b=null;
        Token c=null;
        Token d=null;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1595:9: ( NEW createdName a= LBRACKET b= RBRACKET (c= LBRACKET d= RBRACKET )* arrayInitializer )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1595:9: NEW createdName a= LBRACKET b= RBRACKET (c= LBRACKET d= RBRACKET )* arrayInitializer
        {
        match(input,NEW,FOLLOW_NEW_in_synpred277_JavaTypo8621); if (state.failed) return ;

        pushFollow(FOLLOW_createdName_in_synpred277_JavaTypo8623);
        createdName();

        state._fsp--;
        if (state.failed) return ;

        a=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred277_JavaTypo8635); if (state.failed) return ;

        b=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred277_JavaTypo8639); if (state.failed) return ;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1597:9: (c= LBRACKET d= RBRACKET )*
        loop238:
        do {
            int alt238=2;
            int LA238_0 = input.LA(1);

            if ( (LA238_0==LBRACKET) ) {
                alt238=1;
            }


            switch (alt238) {
        	case 1 :
        	    // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1597:10: c= LBRACKET d= RBRACKET
        	    {
        	    c=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred277_JavaTypo8652); if (state.failed) return ;

        	    d=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred277_JavaTypo8656); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop238;
            }
        } while (true);


        pushFollow(FOLLOW_arrayInitializer_in_synpred277_JavaTypo8679);
        arrayInitializer();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred277_JavaTypo

    // $ANTLR start synpred278_JavaTypo
    public final void synpred278_JavaTypo_fragment() throws RecognitionException {
        Token a=null;
        Token b=null;

        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1604:13: (a= LBRACKET expression b= RBRACKET )
        // D:\\Documents\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTypo.g:1604:13: a= LBRACKET expression b= RBRACKET
        {
        a=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred278_JavaTypo8743); if (state.failed) return ;

        pushFollow(FOLLOW_expression_in_synpred278_JavaTypo8745);
        expression();

        state._fsp--;
        if (state.failed) return ;

        b=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred278_JavaTypo8761); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred278_JavaTypo

    // Delegated rules

    public final boolean synpred182_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred182_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred138_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred138_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred116_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred116_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred277_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred277_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred149_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred149_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred159_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred159_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred190_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred190_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred195_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred195_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred87_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred87_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred136_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred136_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred250_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred250_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred38_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred38_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred161_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred161_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred144_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred144_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred141_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred141_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred140_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred140_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred278_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred278_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred137_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred137_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred66_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred66_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred262_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred262_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred121_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred121_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred85_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred85_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred56_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred56_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred174_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred174_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred181_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred181_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred274_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred274_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred68_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred68_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred67_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred67_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred156_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred156_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred86_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred86_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred246_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred246_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred84_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred84_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred191_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred191_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred178_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred178_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred247_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred247_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred153_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred153_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred152_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred152_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred151_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred151_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred199_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred199_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred179_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred179_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred74_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred74_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred145_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred145_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred275_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred275_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred72_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred72_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred154_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred154_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred12_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred12_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred173_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred173_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred249_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred249_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred244_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred244_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred139_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred139_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred117_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred117_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred240_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred240_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred114_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred114_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred155_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred155_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred2_JavaTypo() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred2_JavaTypo_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


 

    public static final BitSet FOLLOW_annotations_in_compilationUnit116 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
    public static final BitSet FOLLOW_packageDeclaration_in_compilationUnit120 = new BitSet(new long[]{0x4001020002000012L,0x022081820E00C002L});
    public static final BitSet FOLLOW_importDeclaration_in_compilationUnit125 = new BitSet(new long[]{0x4001020002000012L,0x022081820E00C002L});
    public static final BitSet FOLLOW_typeDeclaration_in_compilationUnit130 = new BitSet(new long[]{0x0001020002000012L,0x022081820E00C002L});
    public static final BitSet FOLLOW_PACKAGE_in_packageDeclaration158 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_qualifiedName_in_packageDeclaration160 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_packageDeclaration162 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IMPORT_in_importDeclaration191 = new BitSet(new long[]{0x0800000000000000L,0x0000008000000000L});
    public static final BitSet FOLLOW_STATIC_in_importDeclaration203 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration226 = new BitSet(new long[]{0x0000000200000000L});
    public static final BitSet FOLLOW_DOT_in_importDeclaration228 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L});
    public static final BitSet FOLLOW_STAR_in_importDeclaration230 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_importDeclaration240 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IMPORT_in_importDeclaration267 = new BitSet(new long[]{0x0800000000000000L,0x0000008000000000L});
    public static final BitSet FOLLOW_STATIC_in_importDeclaration278 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration301 = new BitSet(new long[]{0x0000000200000000L});
    public static final BitSet FOLLOW_DOT_in_importDeclaration314 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration316 = new BitSet(new long[]{0x0000000200000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_DOT_in_importDeclaration342 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L});
    public static final BitSet FOLLOW_STAR_in_importDeclaration344 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_importDeclaration367 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedImportName397 = new BitSet(new long[]{0x0000000200000002L});
    public static final BitSet FOLLOW_DOT_in_qualifiedImportName408 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedImportName410 = new BitSet(new long[]{0x0000000200000002L});
    public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration448 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_typeDeclaration458 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_classOrInterfaceDeclaration484 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration494 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotation_in_modifiers529 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_PUBLIC_in_modifiers539 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_PROTECTED_in_modifiers552 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_PRIVATE_in_modifiers564 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_STATIC_in_modifiers577 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_ABSTRACT_in_modifiers590 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_FINAL_in_modifiers602 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_NATIVE_in_modifiers615 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_SYNCHRONIZED_in_modifiers628 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_TRANSIENT_in_modifiers640 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_VOLATILE_in_modifiers652 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_STRICTFP_in_modifiers664 = new BitSet(new long[]{0x0001000000000012L,0x022081800E00C000L});
    public static final BitSet FOLLOW_PUBLIC_in_mods699 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_PROTECTED_in_mods712 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_PRIVATE_in_mods724 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_STATIC_in_mods737 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_ABSTRACT_in_mods750 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_FINAL_in_mods762 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_NATIVE_in_mods775 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_SYNCHRONIZED_in_mods788 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_TRANSIENT_in_mods800 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_VOLATILE_in_mods812 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_STRICTFP_in_mods824 = new BitSet(new long[]{0x0001000000000012L,0x022081800E008000L});
    public static final BitSet FOLLOW_FINAL_in_variableModifiers855 = new BitSet(new long[]{0x0001000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_annotation_in_variableModifiers871 = new BitSet(new long[]{0x0001000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_normalClassDeclaration_in_classDeclaration910 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumDeclaration_in_classDeclaration921 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotations_in_normalClassDeclaration942 = new BitSet(new long[]{0x0001000002000010L,0x022081800E008000L});
    public static final BitSet FOLLOW_mods_in_normalClassDeclaration945 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_CLASS_in_normalClassDeclaration947 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_normalClassDeclaration949 = new BitSet(new long[]{0x2000100000000000L,0x0000000000001040L});
    public static final BitSet FOLLOW_typeParameters_in_normalClassDeclaration960 = new BitSet(new long[]{0x2000100000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_EXTENDS_in_normalClassDeclaration982 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_normalClassDeclaration984 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_IMPLEMENTS_in_normalClassDeclaration1008 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_typeList_in_normalClassDeclaration1010 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_classBody_in_normalClassDeclaration1033 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_typeParameters1082 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_typeParameter_in_typeParameters1096 = new BitSet(new long[]{0x0080000008000000L});
    public static final BitSet FOLLOW_COMMA_in_typeParameters1111 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_typeParameter_in_typeParameters1113 = new BitSet(new long[]{0x0080000008000000L});
    public static final BitSet FOLLOW_GT_in_typeParameters1140 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_typeParameter1170 = new BitSet(new long[]{0x0000100000000002L});
    public static final BitSet FOLLOW_EXTENDS_in_typeParameter1181 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_typeBound_in_typeParameter1183 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_typeBound1217 = new BitSet(new long[]{0x0000000000000022L});
    public static final BitSet FOLLOW_AMP_in_typeBound1228 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_typeBound1230 = new BitSet(new long[]{0x0000000000000022L});
    public static final BitSet FOLLOW_annotations_in_enumDeclaration1264 = new BitSet(new long[]{0x0001020000000010L,0x022081800E008000L});
    public static final BitSet FOLLOW_mods_in_enumDeclaration1267 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_ENUM_in_enumDeclaration1279 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_enumDeclaration1302 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_IMPLEMENTS_in_enumDeclaration1313 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_typeList_in_enumDeclaration1315 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_enumBody_in_enumDeclaration1348 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_enumBody1373 = new BitSet(new long[]{0x0800000008000000L,0x0000000220004000L});
    public static final BitSet FOLLOW_enumConstants_in_enumBody1384 = new BitSet(new long[]{0x0000000008000000L,0x0000000220000000L});
    public static final BitSet FOLLOW_COMMA_in_enumBody1407 = new BitSet(new long[]{0x0000000000000000L,0x0000000220000000L});
    public static final BitSet FOLLOW_enumBodyDeclarations_in_enumBody1424 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_RBRACE_in_enumBody1446 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumConstant_in_enumConstants1476 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_COMMA_in_enumConstants1487 = new BitSet(new long[]{0x0800000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_enumConstant_in_enumConstants1489 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_annotations_in_enumConstant1525 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_enumConstant1546 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000840L});
    public static final BitSet FOLLOW_arguments_in_enumConstant1557 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L});
    public static final BitSet FOLLOW_classBody_in_enumConstant1579 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_enumBodyDeclarations1620 = new BitSet(new long[]{0x0805020402814012L,0x032081860E00D243L});
    public static final BitSet FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1633 = new BitSet(new long[]{0x0805020402814012L,0x032081860E00D243L});
    public static final BitSet FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1668 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1678 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotations_in_normalInterfaceDeclaration1702 = new BitSet(new long[]{0x0001000000000010L,0x022081800E008002L});
    public static final BitSet FOLLOW_mods_in_normalInterfaceDeclaration1705 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_INTERFACE_in_normalInterfaceDeclaration1707 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1709 = new BitSet(new long[]{0x0000100000000000L,0x0000000000001040L});
    public static final BitSet FOLLOW_typeParameters_in_normalInterfaceDeclaration1720 = new BitSet(new long[]{0x0000100000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_EXTENDS_in_normalInterfaceDeclaration1742 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_typeList_in_normalInterfaceDeclaration1744 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_interfaceBody_in_normalInterfaceDeclaration1777 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_typeList1807 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_COMMA_in_typeList1818 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_typeList1820 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_LBRACE_in_classBody1853 = new BitSet(new long[]{0x0805020402814010L,0x032081862E00D243L});
    public static final BitSet FOLLOW_classBodyDeclaration_in_classBody1865 = new BitSet(new long[]{0x0805020402814010L,0x032081862E00D243L});
    public static final BitSet FOLLOW_RBRACE_in_classBody1887 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_interfaceBody1907 = new BitSet(new long[]{0x0805020402814010L,0x032081862E00D203L});
    public static final BitSet FOLLOW_interfaceBodyDeclaration_in_interfaceBody1919 = new BitSet(new long[]{0x0805020402814010L,0x032081862E00D203L});
    public static final BitSet FOLLOW_RBRACE_in_interfaceBody1941 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_classBodyDeclaration1971 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STATIC_in_classBodyDeclaration1983 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_classBodyDeclaration1993 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_classBodyDeclaration2014 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_memberDecl_in_classBodyDeclaration2024 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fieldDeclaration_in_memberDecl2045 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_methodDeclaration_in_memberDecl2058 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_memberDecl2071 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceDeclaration_in_memberDecl2084 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotations_in_methodDeclaration2123 = new BitSet(new long[]{0x0801000000000010L,0x022081800E009000L});
    public static final BitSet FOLLOW_mods_in_methodDeclaration2126 = new BitSet(new long[]{0x0800000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_typeParameters_in_methodDeclaration2137 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration2158 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_formalParameters_in_methodDeclaration2168 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000040L});
    public static final BitSet FOLLOW_THROWS_in_methodDeclaration2179 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration2181 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_LBRACE_in_methodDeclaration2206 = new BitSet(new long[]{0x181D820D4381C310L,0x07F6F786AF43DE47L});
    public static final BitSet FOLLOW_explicitConstructorInvocation_in_methodDeclaration2218 = new BitSet(new long[]{0x181D820D4381C310L,0x07F6F786AF43CE47L});
    public static final BitSet FOLLOW_blockStatement_in_methodDeclaration2240 = new BitSet(new long[]{0x181D820D4381C310L,0x07F6F786AF43CE47L});
    public static final BitSet FOLLOW_RBRACE_in_methodDeclaration2263 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotations_in_methodDeclaration2283 = new BitSet(new long[]{0x0805000400814010L,0x032081840E009201L});
    public static final BitSet FOLLOW_mods_in_methodDeclaration2286 = new BitSet(new long[]{0x0804000400814000L,0x0100000400001201L});
    public static final BitSet FOLLOW_typeParameters_in_methodDeclaration2297 = new BitSet(new long[]{0x0804000400814000L,0x0100000400000201L});
    public static final BitSet FOLLOW_type_in_methodDeclaration2319 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_VOID_in_methodDeclaration2333 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration2356 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_formalParameters_in_methodDeclaration2366 = new BitSet(new long[]{0x0000000000000000L,0x00080002000000C0L});
    public static final BitSet FOLLOW_LBRACKET_in_methodDeclaration2377 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_methodDeclaration2379 = new BitSet(new long[]{0x0000000000000000L,0x00080002000000C0L});
    public static final BitSet FOLLOW_THROWS_in_methodDeclaration2403 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration2405 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000040L});
    public static final BitSet FOLLOW_block_in_methodDeclaration2462 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_methodDeclaration2478 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_fieldDeclaration2521 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_fieldDeclaration2531 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_variableDeclarator_in_fieldDeclaration2541 = new BitSet(new long[]{0x0000000008000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_COMMA_in_fieldDeclaration2552 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_variableDeclarator_in_fieldDeclaration2554 = new BitSet(new long[]{0x0000000008000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_fieldDeclaration2577 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_variableDeclarator2599 = new BitSet(new long[]{0x0000040000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_variableDeclarator2610 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_variableDeclarator2612 = new BitSet(new long[]{0x0000040000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_EQ_in_variableDeclarator2636 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E45L});
    public static final BitSet FOLLOW_variableInitializer_in_variableDeclarator2638 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration2689 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration2699 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration2709 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_interfaceBodyDeclaration2719 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_interfaceBodyDeclaration2729 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_interfaceMethodDeclaration2751 = new BitSet(new long[]{0x0804000400814000L,0x0100000400001201L});
    public static final BitSet FOLLOW_typeParameters_in_interfaceMethodDeclaration2762 = new BitSet(new long[]{0x0804000400814000L,0x0100000400000201L});
    public static final BitSet FOLLOW_type_in_interfaceMethodDeclaration2784 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_VOID_in_interfaceMethodDeclaration2795 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration2817 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_formalParameters_in_interfaceMethodDeclaration2827 = new BitSet(new long[]{0x0000000000000000L,0x0008000200000080L});
    public static final BitSet FOLLOW_LBRACKET_in_interfaceMethodDeclaration2838 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_interfaceMethodDeclaration2840 = new BitSet(new long[]{0x0000000000000000L,0x0008000200000080L});
    public static final BitSet FOLLOW_THROWS_in_interfaceMethodDeclaration2864 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration2866 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_interfaceMethodDeclaration2881 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_interfaceFieldDeclaration2905 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_interfaceFieldDeclaration2907 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2911 = new BitSet(new long[]{0x0000000008000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_COMMA_in_interfaceFieldDeclaration2922 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2924 = new BitSet(new long[]{0x0000000008000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_interfaceFieldDeclaration2947 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_type2970 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_type2981 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_type2983 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_primitiveType_in_type3006 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_type3017 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_type3019 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_IDENTIFIER_in_classOrInterfaceType3053 = new BitSet(new long[]{0x0000000200000002L,0x0000000000001000L});
    public static final BitSet FOLLOW_typeArguments_in_classOrInterfaceType3064 = new BitSet(new long[]{0x0000000200000002L});
    public static final BitSet FOLLOW_LT_in_classOrInterfaceType3070 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_GT_in_classOrInterfaceType3074 = new BitSet(new long[]{0x0000000200000002L});
    public static final BitSet FOLLOW_DOT_in_classOrInterfaceType3098 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_classOrInterfaceType3100 = new BitSet(new long[]{0x0000000200000002L,0x0000000000001000L});
    public static final BitSet FOLLOW_typeArguments_in_classOrInterfaceType3115 = new BitSet(new long[]{0x0000000200000002L});
    public static final BitSet FOLLOW_LT_in_classOrInterfaceType3121 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_GT_in_classOrInterfaceType3125 = new BitSet(new long[]{0x0000000200000002L});
    public static final BitSet FOLLOW_BOOLEAN_in_primitiveType3188 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CHAR_in_primitiveType3201 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BYTE_in_primitiveType3214 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SHORT_in_primitiveType3227 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INT_in_primitiveType3240 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LONG_in_primitiveType3253 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FLOAT_in_primitiveType3266 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOUBLE_in_primitiveType3279 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_typeArguments3302 = new BitSet(new long[]{0x0804000400814000L,0x0000000410000201L});
    public static final BitSet FOLLOW_typeArgument_in_typeArguments3304 = new BitSet(new long[]{0x0080000008000000L});
    public static final BitSet FOLLOW_COMMA_in_typeArguments3315 = new BitSet(new long[]{0x0804000400814000L,0x0000000410000201L});
    public static final BitSet FOLLOW_typeArgument_in_typeArguments3317 = new BitSet(new long[]{0x0080000008000000L});
    public static final BitSet FOLLOW_GT_in_typeArguments3342 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_typeArgument3372 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_QUES_in_typeArgument3382 = new BitSet(new long[]{0x0000100000000002L,0x0000200000000000L});
    public static final BitSet FOLLOW_EXTENDS_in_typeArgument3407 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_SUPER_in_typeArgument3424 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_typeArgument3456 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedName_in_qualifiedNameList3497 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_COMMA_in_qualifiedNameList3508 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_qualifiedName_in_qualifiedNameList3510 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_LPAREN_in_formalParameters3543 = new BitSet(new long[]{0x0805000400814000L,0x0000000500004201L});
    public static final BitSet FOLLOW_formalParameterDecls_in_formalParameters3554 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_formalParameters3576 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3606 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls3616 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_COMMA_in_formalParameterDecls3627 = new BitSet(new long[]{0x0805000400814000L,0x0000000400004201L});
    public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls3629 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls3653 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_COMMA_in_formalParameterDecls3663 = new BitSet(new long[]{0x0805000400814000L,0x0000000400004201L});
    public static final BitSet FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3687 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_normalParameterDecl3707 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_normalParameterDecl3709 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_normalParameterDecl3711 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_normalParameterDecl3722 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_normalParameterDecl3724 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_variableModifiers_in_ellipsisParameterDecl3757 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_ellipsisParameterDecl3767 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_ELLIPSIS_in_ellipsisParameterDecl3770 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_ellipsisParameterDecl3781 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3813 = new BitSet(new long[]{0x0000000000000000L,0x0002200000000000L});
    public static final BitSet FOLLOW_THIS_in_explicitConstructorInvocation3840 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_SUPER_in_explicitConstructorInvocation3854 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_arguments_in_explicitConstructorInvocation3877 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_explicitConstructorInvocation3879 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primary_in_explicitConstructorInvocation3900 = new BitSet(new long[]{0x0000000200000000L});
    public static final BitSet FOLLOW_DOT_in_explicitConstructorInvocation3910 = new BitSet(new long[]{0x0000000000000000L,0x0000200000001000L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3921 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_SUPER_in_explicitConstructorInvocation3942 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_arguments_in_explicitConstructorInvocation3952 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_explicitConstructorInvocation3954 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedName3984 = new BitSet(new long[]{0x0000000200000002L});
    public static final BitSet FOLLOW_DOT_in_qualifiedName3995 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedName3997 = new BitSet(new long[]{0x0000000200000002L});
    public static final BitSet FOLLOW_annotation_in_annotations4031 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_MONKEYS_AT_in_annotation4064 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_qualifiedName_in_annotation4066 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000800L});
    public static final BitSet FOLLOW_LPAREN_in_annotation4080 = new BitSet(new long[]{0x080C800C01814200L,0x0152360501434E45L});
    public static final BitSet FOLLOW_elementValuePairs_in_annotation4107 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_elementValue_in_annotation4131 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_annotation4167 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_elementValuePair_in_elementValuePairs4223 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_COMMA_in_elementValuePairs4234 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_elementValuePair_in_elementValuePairs4236 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_elementValuePair4270 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_EQ_in_elementValuePair4272 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401434E45L});
    public static final BitSet FOLLOW_elementValue_in_elementValuePair4274 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalExpression_in_elementValue4297 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotation_in_elementValue4307 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_elementValueArrayInitializer_in_elementValue4317 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_elementValueArrayInitializer4337 = new BitSet(new long[]{0x080C800C09814200L,0x0152360421434E45L});
    public static final BitSet FOLLOW_elementValue_in_elementValueArrayInitializer4348 = new BitSet(new long[]{0x0000000008000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COMMA_in_elementValueArrayInitializer4365 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401434E45L});
    public static final BitSet FOLLOW_elementValue_in_elementValueArrayInitializer4367 = new BitSet(new long[]{0x0000000008000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COMMA_in_elementValueArrayInitializer4400 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_RBRACE_in_elementValueArrayInitializer4407 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotations_in_annotationTypeDeclaration4430 = new BitSet(new long[]{0x0001000000000010L,0x022081800E00C000L});
    public static final BitSet FOLLOW_mods_in_annotationTypeDeclaration4433 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration4435 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_INTERFACE_in_annotationTypeDeclaration4445 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_annotationTypeDeclaration4455 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_annotationTypeBody_in_annotationTypeDeclaration4475 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_annotationTypeBody4506 = new BitSet(new long[]{0x0805020402814010L,0x022081862E00C203L});
    public static final BitSet FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody4518 = new BitSet(new long[]{0x0805020402814010L,0x022081862E00C203L});
    public static final BitSet FOLLOW_RBRACE_in_annotationTypeBody4540 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration4572 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration4582 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration4592 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration4602 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration4612 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration4622 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_annotationTypeElementDeclaration4632 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_annotationMethodDeclaration4654 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_annotationMethodDeclaration4656 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_annotationMethodDeclaration4658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_LPAREN_in_annotationMethodDeclaration4668 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_annotationMethodDeclaration4670 = new BitSet(new long[]{0x0000000080000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_DEFAULT_in_annotationMethodDeclaration4673 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401434E45L});
    public static final BitSet FOLLOW_elementValue_in_annotationMethodDeclaration4675 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_annotationMethodDeclaration4706 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_block4740 = new BitSet(new long[]{0x181D820D4381C310L,0x07F6F786AF43CE47L});
    public static final BitSet FOLLOW_blockStatement_in_block4758 = new BitSet(new long[]{0x181D820D4381C310L,0x07F6F786AF43CE47L});
    public static final BitSet FOLLOW_RBRACE_in_block4779 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclarationStatement_in_blockStatement4811 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_blockStatement4821 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_blockStatement4831 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement4852 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_localVariableDeclarationStatement4862 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_localVariableDeclaration4892 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_localVariableDeclaration4894 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_variableDeclarator_in_localVariableDeclaration4904 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_COMMA_in_localVariableDeclaration4915 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_variableDeclarator_in_localVariableDeclaration4917 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_block_in_statement4950 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSERT_in_statement4974 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_statement4994 = new BitSet(new long[]{0x0000000004000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_COLON_in_statement4997 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_statement4999 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5005 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSERT_in_statement5033 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_statement5036 = new BitSet(new long[]{0x0000000004000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_COLON_in_statement5039 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_statement5041 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5047 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_statement5065 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_parExpression_in_statement5074 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_block_in_statement5079 = new BitSet(new long[]{0x0000010000000002L});
    public static final BitSet FOLLOW_statement_in_statement5083 = new BitSet(new long[]{0x0000010000000002L});
    public static final BitSet FOLLOW_ELSE_in_statement5095 = new BitSet(new long[]{0x1000000000000000L});
    public static final BitSet FOLLOW_IF_in_statement5099 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_parExpression_in_statement5101 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_block_in_statement5106 = new BitSet(new long[]{0x0000010000000002L});
    public static final BitSet FOLLOW_statement_in_statement5110 = new BitSet(new long[]{0x0000010000000002L});
    public static final BitSet FOLLOW_ELSE_in_statement5131 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_block_in_statement5136 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_statement5140 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forstatement_in_statement5164 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WHILE_in_statement5174 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_parExpression_in_statement5176 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_block_in_statement5181 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_statement5185 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DO_in_statement5198 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_block_in_statement5203 = new BitSet(new long[]{0x0000000000000000L,0x0400000000000000L});
    public static final BitSet FOLLOW_statement_in_statement5207 = new BitSet(new long[]{0x0000000000000000L,0x0400000000000000L});
    public static final BitSet FOLLOW_WHILE_in_statement5210 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_parExpression_in_statement5212 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5214 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_trystatement_in_statement5226 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SWITCH_in_statement5236 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_parExpression_in_statement5238 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_LBRACE_in_statement5240 = new BitSet(new long[]{0x0000000080200000L,0x0000000020000000L});
    public static final BitSet FOLLOW_switchBlockStatementGroups_in_statement5242 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_RBRACE_in_statement5244 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SYNCHRONIZED_in_statement5256 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_parExpression_in_statement5258 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_statement5260 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RETURN_in_statement5272 = new BitSet(new long[]{0x080C800C01814200L,0x0152360601430E05L});
    public static final BitSet FOLLOW_expression_in_statement5275 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5280 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THROW_in_statement5292 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_statement5294 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5296 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BREAK_in_statement5308 = new BitSet(new long[]{0x0800000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_statement5323 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5340 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CONTINUE_in_statement5360 = new BitSet(new long[]{0x0800000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_statement5375 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5392 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_statement5412 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5415 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_statement5427 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_COLON_in_statement5429 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_statement_in_statement5431 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_statement5443 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups5467 = new BitSet(new long[]{0x0000000080200002L});
    public static final BitSet FOLLOW_switchLabel_in_switchBlockStatementGroup5496 = new BitSet(new long[]{0x181D820D4381C312L,0x07F6F7868F43CE47L});
    public static final BitSet FOLLOW_blockStatement_in_switchBlockStatementGroup5507 = new BitSet(new long[]{0x181D820D4381C312L,0x07F6F7868F43CE47L});
    public static final BitSet FOLLOW_CASE_in_switchLabel5538 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_switchLabel5540 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_COLON_in_switchLabel5542 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DEFAULT_in_switchLabel5555 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_COLON_in_switchLabel5557 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TRY_in_trystatement5579 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_trystatement5585 = new BitSet(new long[]{0x0002000000400000L});
    public static final BitSet FOLLOW_catches_in_trystatement5599 = new BitSet(new long[]{0x0002000000000000L});
    public static final BitSet FOLLOW_FINALLY_in_trystatement5603 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_trystatement5607 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_trystatement5623 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FINALLY_in_trystatement5639 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_trystatement5643 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TRY_in_trystatement5675 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_resourceSpecification_in_trystatement5679 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_trystatement5683 = new BitSet(new long[]{0x0002000000400002L});
    public static final BitSet FOLLOW_catches_in_trystatement5693 = new BitSet(new long[]{0x0002000000000000L});
    public static final BitSet FOLLOW_FINALLY_in_trystatement5697 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_trystatement5701 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_trystatement5717 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FINALLY_in_trystatement5733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_trystatement5737 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_resourceSpecification5782 = new BitSet(new long[]{0x0805000400814000L,0x0000000400004201L});
    public static final BitSet FOLLOW_resource_in_resourceSpecification5784 = new BitSet(new long[]{0x0000000000000000L,0x0000000300000000L});
    public static final BitSet FOLLOW_SEMI_in_resourceSpecification5789 = new BitSet(new long[]{0x0805000400814000L,0x0000000400004201L});
    public static final BitSet FOLLOW_resource_in_resourceSpecification5791 = new BitSet(new long[]{0x0000000000000000L,0x0000000300000000L});
    public static final BitSet FOLLOW_SEMI_in_resourceSpecification5800 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_resourceSpecification5806 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_resource5830 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_resource5837 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_resource5841 = new BitSet(new long[]{0x0000040000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_resource5844 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_resource5846 = new BitSet(new long[]{0x0000040000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_EQ_in_resource5853 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_resource5856 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catchClause_in_catches5879 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_catchClause_in_catches5890 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_CATCH_in_catchClause5921 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_LPAREN_in_catchClause5923 = new BitSet(new long[]{0x0805000400814000L,0x0000000400004201L});
    public static final BitSet FOLLOW_formalParameter_in_catchClause5925 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_catchClause5935 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_catchClause5939 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_formalParameter5970 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_formalParameter5972 = new BitSet(new long[]{0x0800000000000800L});
    public static final BitSet FOLLOW_BAR_in_formalParameter5975 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_formalParameter5977 = new BitSet(new long[]{0x0800000000000800L});
    public static final BitSet FOLLOW_IDENTIFIER_in_formalParameter5983 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_formalParameter5994 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_formalParameter5996 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_FOR_in_forstatement6048 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_LPAREN_in_forstatement6050 = new BitSet(new long[]{0x0805000400814000L,0x0000000400004201L});
    public static final BitSet FOLLOW_variableModifiers_in_forstatement6052 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_forstatement6054 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_forstatement6056 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_COLON_in_forstatement6058 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_forstatement6069 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_forstatement6071 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_block_in_forstatement6077 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_forstatement6081 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_forstatement6111 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_LPAREN_in_forstatement6113 = new BitSet(new long[]{0x080D800C01814200L,0x0152360601434E05L});
    public static final BitSet FOLLOW_forInit_in_forstatement6133 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_forstatement6156 = new BitSet(new long[]{0x080C800C01814200L,0x0152360601430E05L});
    public static final BitSet FOLLOW_expression_in_forstatement6177 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_forstatement6200 = new BitSet(new long[]{0x080C800C01814200L,0x0152360501430E05L});
    public static final BitSet FOLLOW_expressionList_in_forstatement6221 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_forstatement6242 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_block_in_forstatement6248 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_forstatement6252 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_forInit6283 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_forInit6285 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_forInit6295 = new BitSet(new long[]{0x0000040008000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_forInit6306 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_forInit6308 = new BitSet(new long[]{0x0000040008000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_EQ_in_forInit6332 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E45L});
    public static final BitSet FOLLOW_variableInitializer_in_forInit6334 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_COMMA_in_forInit6358 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_variableDeclarator_in_forInit6360 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_expressionList_in_forInit6401 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_parExpression6421 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_parExpression6423 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_parExpression6425 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_expressionList6447 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_COMMA_in_expressionList6458 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_expressionList6460 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_conditionalExpression_in_expression6494 = new BitSet(new long[]{0x0080040000102082L,0x0000085000A01000L});
    public static final BitSet FOLLOW_assignmentOperator_in_expression6505 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_expression6507 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_EQ_in_assignmentOperator6539 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PLUSEQ_in_assignmentOperator6553 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUBEQ_in_assignmentOperator6567 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STAREQ_in_assignmentOperator6581 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SLASHEQ_in_assignmentOperator6595 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_AMPEQ_in_assignmentOperator6609 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BAREQ_in_assignmentOperator6623 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CARETEQ_in_assignmentOperator6637 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PERCENTEQ_in_assignmentOperator6651 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_assignmentOperator6665 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_LT_in_assignmentOperator6667 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_EQ_in_assignmentOperator6669 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator6683 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator6685 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator6687 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_EQ_in_assignmentOperator6689 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator6703 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator6705 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_EQ_in_assignmentOperator6707 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalOrExpression_in_conditionalExpression6731 = new BitSet(new long[]{0x0000000000000002L,0x0000000010000000L});
    public static final BitSet FOLLOW_QUES_in_conditionalExpression6742 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_conditionalExpression6744 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_COLON_in_conditionalExpression6746 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_conditionalExpression_in_conditionalExpression6748 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression6781 = new BitSet(new long[]{0x0000000000001002L});
    public static final BitSet FOLLOW_BARBAR_in_conditionalOrExpression6792 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression6794 = new BitSet(new long[]{0x0000000000001002L});
    public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression6827 = new BitSet(new long[]{0x0000000000000042L});
    public static final BitSet FOLLOW_AMPAMP_in_conditionalAndExpression6838 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression6840 = new BitSet(new long[]{0x0000000000000042L});
    public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression6873 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_BAR_in_inclusiveOrExpression6884 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression6886 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression6919 = new BitSet(new long[]{0x0000000000080002L});
    public static final BitSet FOLLOW_CARET_in_exclusiveOrExpression6930 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression6932 = new BitSet(new long[]{0x0000000000080002L});
    public static final BitSet FOLLOW_equalityExpression_in_andExpression6965 = new BitSet(new long[]{0x0000000000000022L});
    public static final BitSet FOLLOW_AMP_in_andExpression6976 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_equalityExpression_in_andExpression6978 = new BitSet(new long[]{0x0000000000000022L});
    public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression7011 = new BitSet(new long[]{0x0000080000000402L});
    public static final BitSet FOLLOW_EQEQ_in_equalityExpression7042 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_BANGEQ_in_equalityExpression7062 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression7092 = new BitSet(new long[]{0x0000080000000402L});
    public static final BitSet FOLLOW_relationalExpression_in_instanceOfExpression7123 = new BitSet(new long[]{0x8000000000000002L});
    public static final BitSet FOLLOW_INSTANCEOF_in_instanceOfExpression7134 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_instanceOfExpression7136 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpression7169 = new BitSet(new long[]{0x0080000000000002L,0x0000000000001000L});
    public static final BitSet FOLLOW_relationalOp_in_relationalExpression7180 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpression7182 = new BitSet(new long[]{0x0080000000000002L,0x0000000000001000L});
    public static final BitSet FOLLOW_LT_in_relationalOp7214 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_EQ_in_relationalOp7216 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_relationalOp7229 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_EQ_in_relationalOp7231 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_relationalOp7244 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_relationalOp7257 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_additiveExpression_in_shiftExpression7279 = new BitSet(new long[]{0x0080000000000002L,0x0000000000001000L});
    public static final BitSet FOLLOW_shiftOp_in_shiftExpression7290 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_additiveExpression_in_shiftExpression7292 = new BitSet(new long[]{0x0080000000000002L,0x0000000000001000L});
    public static final BitSet FOLLOW_LT_in_shiftOp7327 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_LT_in_shiftOp7331 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_shiftOp7346 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_GT_in_shiftOp7348 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_GT_in_shiftOp7352 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_shiftOp7367 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_GT_in_shiftOp7371 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression7394 = new BitSet(new long[]{0x0000000000000002L,0x0000040000400000L});
    public static final BitSet FOLLOW_PLUS_in_additiveExpression7425 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_SUB_in_additiveExpression7445 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression7475 = new BitSet(new long[]{0x0000000000000002L,0x0000040000400000L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression7513 = new BitSet(new long[]{0x0000000000000002L,0x0000002800100000L});
    public static final BitSet FOLLOW_STAR_in_multiplicativeExpression7544 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_SLASH_in_multiplicativeExpression7565 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_PERCENT_in_multiplicativeExpression7585 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression7615 = new BitSet(new long[]{0x0000000000000002L,0x0000002800100000L});
    public static final BitSet FOLLOW_PLUS_in_unaryExpression7648 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression7651 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUB_in_unaryExpression7664 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression7666 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PLUSPLUS_in_unaryExpression7679 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression7681 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUBSUB_in_unaryExpression7693 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression7695 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression7708 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TILDE_in_unaryExpressionNotPlusMinus7729 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus7731 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BANG_in_unaryExpressionNotPlusMinus7743 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus7745 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_castExpression_in_unaryExpressionNotPlusMinus7757 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primary_in_unaryExpressionNotPlusMinus7767 = new BitSet(new long[]{0x0000000200000002L,0x0000100001000080L});
    public static final BitSet FOLLOW_selector_in_unaryExpressionNotPlusMinus7778 = new BitSet(new long[]{0x0000000200000002L,0x0000100001000080L});
    public static final BitSet FOLLOW_PLUSPLUS_in_unaryExpressionNotPlusMinus7803 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUBSUB_in_unaryExpressionNotPlusMinus7819 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_castExpression7852 = new BitSet(new long[]{0x0004000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_primitiveType_in_castExpression7854 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_castExpression7856 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_unaryExpression_in_castExpression7858 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_castExpression7871 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_castExpression7873 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_castExpression7875 = new BitSet(new long[]{0x080C800C01814200L,0x0152220400030E05L});
    public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_castExpression7877 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parExpression_in_primary7902 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THIS_in_primary7924 = new BitSet(new long[]{0x0000000200000002L,0x0000000000000880L});
    public static final BitSet FOLLOW_DOT_in_primary7935 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_primary7937 = new BitSet(new long[]{0x0000000200000002L,0x0000000000000880L});
    public static final BitSet FOLLOW_identifierSuffix_in_primary7961 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_primary7992 = new BitSet(new long[]{0x0000000200000002L,0x0000000000000880L});
    public static final BitSet FOLLOW_DOT_in_primary8003 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_primary8005 = new BitSet(new long[]{0x0000000200000002L,0x0000000000000880L});
    public static final BitSet FOLLOW_identifierSuffix_in_primary8029 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUPER_in_primary8050 = new BitSet(new long[]{0x0000000200000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_superSuffix_in_primary8060 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_primary8080 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_creator_in_primary8090 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primitiveType_in_primary8100 = new BitSet(new long[]{0x0000000200000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_primary8111 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_primary8113 = new BitSet(new long[]{0x0000000200000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_DOT_in_primary8136 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_CLASS_in_primary8138 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_in_primary8150 = new BitSet(new long[]{0x0000000200000000L});
    public static final BitSet FOLLOW_DOT_in_primary8152 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_CLASS_in_primary8154 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arguments_in_superSuffix8182 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_superSuffix8192 = new BitSet(new long[]{0x0800000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_typeArguments_in_superSuffix8195 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_superSuffix8216 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000800L});
    public static final BitSet FOLLOW_arguments_in_superSuffix8227 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACKET_in_identifierSuffix8270 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_identifierSuffix8272 = new BitSet(new long[]{0x0000000200000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_DOT_in_identifierSuffix8295 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_CLASS_in_identifierSuffix8297 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACKET_in_identifierSuffix8318 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_identifierSuffix8320 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_identifierSuffix8322 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_arguments_in_identifierSuffix8346 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_identifierSuffix8356 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_CLASS_in_identifierSuffix8358 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_identifierSuffix8371 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_identifierSuffix8373 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_identifierSuffix8375 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_arguments_in_identifierSuffix8377 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_identifierSuffix8389 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L});
    public static final BitSet FOLLOW_THIS_in_identifierSuffix8391 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_identifierSuffix8404 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_SUPER_in_identifierSuffix8406 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_arguments_in_identifierSuffix8408 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_innerCreator_in_identifierSuffix8421 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_selector8443 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_selector8445 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000800L});
    public static final BitSet FOLLOW_arguments_in_selector8456 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_selector8487 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L});
    public static final BitSet FOLLOW_THIS_in_selector8489 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_selector8503 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_SUPER_in_selector8505 = new BitSet(new long[]{0x0000000200000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_superSuffix_in_selector8518 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_innerCreator_in_selector8528 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACKET_in_selector8538 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_selector8540 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_selector8542 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_creator8564 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_creator8566 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_creator8568 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_classCreatorRest_in_creator8570 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_creator8582 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_creator8584 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_classCreatorRest_in_creator8586 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayCreator_in_creator8601 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_arrayCreator8621 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_createdName_in_arrayCreator8623 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_arrayCreator8635 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_arrayCreator8639 = new BitSet(new long[]{0x0000000000000000L,0x00000000000000C0L});
    public static final BitSet FOLLOW_LBRACKET_in_arrayCreator8652 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_arrayCreator8656 = new BitSet(new long[]{0x0000000000000000L,0x00000000000000C0L});
    public static final BitSet FOLLOW_arrayInitializer_in_arrayCreator8679 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_arrayCreator8699 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_createdName_in_arrayCreator8701 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_arrayCreator8713 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_arrayCreator8715 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_arrayCreator8727 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_arrayCreator8743 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_arrayCreator8745 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_arrayCreator8761 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_arrayCreator8799 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_arrayCreator8803 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_arrayInitializer_in_variableInitializer8846 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_variableInitializer8856 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_arrayInitializer8876 = new BitSet(new long[]{0x080C800C09814200L,0x0152360421430E45L});
    public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer8892 = new BitSet(new long[]{0x0000000008000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COMMA_in_arrayInitializer8913 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E45L});
    public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer8915 = new BitSet(new long[]{0x0000000008000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COMMA_in_arrayInitializer8969 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_RBRACE_in_arrayInitializer8985 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_createdName9019 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primitiveType_in_createdName9029 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_innerCreator9050 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L});
    public static final BitSet FOLLOW_NEW_in_innerCreator9052 = new BitSet(new long[]{0x0800000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_innerCreator9063 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_innerCreator9084 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001800L});
    public static final BitSet FOLLOW_typeArguments_in_innerCreator9095 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_classCreatorRest_in_innerCreator9116 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arguments_in_classCreatorRest9147 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L});
    public static final BitSet FOLLOW_classBody_in_classCreatorRest9158 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_nonWildcardTypeArguments9190 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_typeList_in_nonWildcardTypeArguments9192 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_GT_in_nonWildcardTypeArguments9202 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_arguments9232 = new BitSet(new long[]{0x080C800C01814200L,0x0152360501430E05L});
    public static final BitSet FOLLOW_expressionList_in_arguments9235 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_arguments9248 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_classHeader9382 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_CLASS_in_classHeader9384 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_classHeader9386 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_enumHeader9408 = new BitSet(new long[]{0x0800020000000000L});
    public static final BitSet FOLLOW_ENUM_in_enumHeader9411 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_enumHeader9416 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_enumHeader9419 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_interfaceHeader9440 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_INTERFACE_in_interfaceHeader9442 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_interfaceHeader9444 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_annotationHeader9466 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_MONKEYS_AT_in_annotationHeader9468 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_INTERFACE_in_annotationHeader9470 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_annotationHeader9472 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_typeHeader9494 = new BitSet(new long[]{0x0000020002000000L,0x0000000000004002L});
    public static final BitSet FOLLOW_CLASS_in_typeHeader9497 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_ENUM_in_typeHeader9502 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_MONKEYS_AT_in_typeHeader9508 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_INTERFACE_in_typeHeader9515 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_typeHeader9521 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_methodHeader9541 = new BitSet(new long[]{0x0804000400814000L,0x0100000400001201L});
    public static final BitSet FOLLOW_typeParameters_in_methodHeader9543 = new BitSet(new long[]{0x0804000400814000L,0x0100000400000201L});
    public static final BitSet FOLLOW_type_in_methodHeader9547 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_VOID_in_methodHeader9549 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_methodHeader9556 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_LPAREN_in_methodHeader9558 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_fieldHeader9580 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_fieldHeader9582 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_fieldHeader9584 = new BitSet(new long[]{0x0000040008000000L,0x0000000200000080L});
    public static final BitSet FOLLOW_LBRACKET_in_fieldHeader9587 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_fieldHeader9589 = new BitSet(new long[]{0x0000040008000000L,0x0000000200000080L});
    public static final BitSet FOLLOW_EQ_in_fieldHeader9596 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_COMMA_in_fieldHeader9601 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_fieldHeader9606 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_localVariableHeader9629 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_localVariableHeader9631 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_localVariableHeader9633 = new BitSet(new long[]{0x0000040008000000L,0x0000000200000080L});
    public static final BitSet FOLLOW_LBRACKET_in_localVariableHeader9636 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_localVariableHeader9638 = new BitSet(new long[]{0x0000040008000000L,0x0000000200000080L});
    public static final BitSet FOLLOW_EQ_in_localVariableHeader9645 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_COMMA_in_localVariableHeader9650 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_localVariableHeader9655 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotations_in_synpred2_JavaTypo116 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
    public static final BitSet FOLLOW_packageDeclaration_in_synpred2_JavaTypo120 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_synpred12_JavaTypo484 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalClassDeclaration_in_synpred38_JavaTypo910 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalInterfaceDeclaration_in_synpred56_JavaTypo1668 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fieldDeclaration_in_synpred66_JavaTypo2045 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_methodDeclaration_in_synpred67_JavaTypo2058 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_synpred68_JavaTypo2071 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_explicitConstructorInvocation_in_synpred72_JavaTypo2218 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotations_in_synpred74_JavaTypo2123 = new BitSet(new long[]{0x0801000000000010L,0x022081800E009000L});
    public static final BitSet FOLLOW_mods_in_synpred74_JavaTypo2126 = new BitSet(new long[]{0x0800000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_typeParameters_in_synpred74_JavaTypo2137 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred74_JavaTypo2158 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_formalParameters_in_synpred74_JavaTypo2168 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000040L});
    public static final BitSet FOLLOW_THROWS_in_synpred74_JavaTypo2179 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_qualifiedNameList_in_synpred74_JavaTypo2181 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_LBRACE_in_synpred74_JavaTypo2206 = new BitSet(new long[]{0x181D820D4381C310L,0x07F6F786AF43DE47L});
    public static final BitSet FOLLOW_explicitConstructorInvocation_in_synpred74_JavaTypo2218 = new BitSet(new long[]{0x181D820D4381C310L,0x07F6F786AF43CE47L});
    public static final BitSet FOLLOW_blockStatement_in_synpred74_JavaTypo2240 = new BitSet(new long[]{0x181D820D4381C310L,0x07F6F786AF43CE47L});
    public static final BitSet FOLLOW_RBRACE_in_synpred74_JavaTypo2263 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFieldDeclaration_in_synpred84_JavaTypo2689 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceMethodDeclaration_in_synpred85_JavaTypo2699 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceDeclaration_in_synpred86_JavaTypo2709 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_synpred87_JavaTypo2719 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ellipsisParameterDecl_in_synpred114_JavaTypo3606 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalParameterDecl_in_synpred116_JavaTypo3616 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_COMMA_in_synpred116_JavaTypo3627 = new BitSet(new long[]{0x0805000400814000L,0x0000000400004201L});
    public static final BitSet FOLLOW_normalParameterDecl_in_synpred116_JavaTypo3629 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_normalParameterDecl_in_synpred117_JavaTypo3653 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_COMMA_in_synpred117_JavaTypo3663 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_synpred121_JavaTypo3813 = new BitSet(new long[]{0x0000000000000000L,0x0002200000000000L});
    public static final BitSet FOLLOW_set_in_synpred121_JavaTypo3839 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_arguments_in_synpred121_JavaTypo3877 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred121_JavaTypo3879 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationMethodDeclaration_in_synpred136_JavaTypo4572 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFieldDeclaration_in_synpred137_JavaTypo4582 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalClassDeclaration_in_synpred138_JavaTypo4592 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalInterfaceDeclaration_in_synpred139_JavaTypo4602 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumDeclaration_in_synpred140_JavaTypo4612 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationTypeDeclaration_in_synpred141_JavaTypo4622 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclarationStatement_in_synpred144_JavaTypo4811 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_synpred145_JavaTypo4821 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSERT_in_synpred149_JavaTypo4974 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_synpred149_JavaTypo4994 = new BitSet(new long[]{0x0000000004000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_COLON_in_synpred149_JavaTypo4997 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_synpred149_JavaTypo4999 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred149_JavaTypo5005 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSERT_in_synpred151_JavaTypo5033 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_synpred151_JavaTypo5036 = new BitSet(new long[]{0x0000000004000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_COLON_in_synpred151_JavaTypo5039 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_synpred151_JavaTypo5041 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred151_JavaTypo5047 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_synpred152_JavaTypo5079 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_synpred153_JavaTypo5106 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ELSE_in_synpred154_JavaTypo5095 = new BitSet(new long[]{0x1000000000000000L});
    public static final BitSet FOLLOW_IF_in_synpred154_JavaTypo5099 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_parExpression_in_synpred154_JavaTypo5101 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_block_in_synpred154_JavaTypo5106 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_synpred154_JavaTypo5110 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_synpred155_JavaTypo5136 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ELSE_in_synpred156_JavaTypo5131 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_block_in_synpred156_JavaTypo5136 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_synpred156_JavaTypo5140 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_synpred159_JavaTypo5181 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_synpred161_JavaTypo5203 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_synpred173_JavaTypo5412 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred173_JavaTypo5415 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred174_JavaTypo5427 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_COLON_in_synpred174_JavaTypo5429 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_statement_in_synpred174_JavaTypo5431 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_synpred178_JavaTypo5599 = new BitSet(new long[]{0x0002000000000000L});
    public static final BitSet FOLLOW_FINALLY_in_synpred178_JavaTypo5603 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_synpred178_JavaTypo5607 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_synpred179_JavaTypo5623 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_synpred181_JavaTypo5693 = new BitSet(new long[]{0x0002000000000000L});
    public static final BitSet FOLLOW_FINALLY_in_synpred181_JavaTypo5697 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_block_in_synpred181_JavaTypo5701 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_synpred182_JavaTypo5717 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_synpred190_JavaTypo6077 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_synpred191_JavaTypo6048 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_LPAREN_in_synpred191_JavaTypo6050 = new BitSet(new long[]{0x0805000400814000L,0x0000000400004201L});
    public static final BitSet FOLLOW_variableModifiers_in_synpred191_JavaTypo6052 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_synpred191_JavaTypo6054 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred191_JavaTypo6056 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_COLON_in_synpred191_JavaTypo6058 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_synpred191_JavaTypo6069 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_synpred191_JavaTypo6071 = new BitSet(new long[]{0x181C800D4181C300L,0x05D6F60681430E45L});
    public static final BitSet FOLLOW_block_in_synpred191_JavaTypo6077 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_synpred191_JavaTypo6081 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_synpred195_JavaTypo6248 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_synpred199_JavaTypo6283 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_type_in_synpred199_JavaTypo6285 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred199_JavaTypo6295 = new BitSet(new long[]{0x0000040008000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred199_JavaTypo6306 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred199_JavaTypo6308 = new BitSet(new long[]{0x0000040008000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_EQ_in_synpred199_JavaTypo6332 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E45L});
    public static final BitSet FOLLOW_variableInitializer_in_synpred199_JavaTypo6334 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_COMMA_in_synpred199_JavaTypo6358 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_variableDeclarator_in_synpred199_JavaTypo6360 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_castExpression_in_synpred240_JavaTypo7757 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_synpred244_JavaTypo7852 = new BitSet(new long[]{0x0004000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_primitiveType_in_synpred244_JavaTypo7854 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_RPAREN_in_synpred244_JavaTypo7856 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_unaryExpression_in_synpred244_JavaTypo7858 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_synpred246_JavaTypo7935 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred246_JavaTypo7937 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierSuffix_in_synpred247_JavaTypo7961 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_synpred249_JavaTypo8003 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred249_JavaTypo8005 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierSuffix_in_synpred250_JavaTypo8029 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred262_JavaTypo8318 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_synpred262_JavaTypo8320 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred262_JavaTypo8322 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_synpred274_JavaTypo8564 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_synpred274_JavaTypo8566 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_synpred274_JavaTypo8568 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_classCreatorRest_in_synpred274_JavaTypo8570 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_synpred275_JavaTypo8582 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_synpred275_JavaTypo8584 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_classCreatorRest_in_synpred275_JavaTypo8586 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_synpred277_JavaTypo8621 = new BitSet(new long[]{0x0804000400814000L,0x0000000400000201L});
    public static final BitSet FOLLOW_createdName_in_synpred277_JavaTypo8623 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred277_JavaTypo8635 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred277_JavaTypo8639 = new BitSet(new long[]{0x0000000000000000L,0x00000000000000C0L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred277_JavaTypo8652 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred277_JavaTypo8656 = new BitSet(new long[]{0x0000000000000000L,0x00000000000000C0L});
    public static final BitSet FOLLOW_arrayInitializer_in_synpred277_JavaTypo8679 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred278_JavaTypo8743 = new BitSet(new long[]{0x080C800C01814200L,0x0152360401430E05L});
    public static final BitSet FOLLOW_expression_in_synpred278_JavaTypo8745 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred278_JavaTypo8761 = new BitSet(new long[]{0x0000000000000002L});

}